From 2db097577dc2c6ecd48509e4280a443e829b53b0 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Tue, 7 Jul 2026 19:20:07 -0600
Subject: [PATCH 01/25] Add agent session hooks: auto memory brief at start,
 proposal-only capture at end

lnk connect claude-code --hooks installs SessionStart/SessionEnd hooks that
run the new agent-agnostic 'lnk hook' runtime: session-start injects a bounded
project-scoped memory brief, session-end extracts bounded transcript text
(skipping tool calls/outputs) into the review-gated session-end capture path.
Settings writes are idempotent and preserve existing user hooks; the hook
runtime never fails the agent session. Claude Code is the first wired agent;
the hook agent table is ready for others.
---
 CHANGELOG.md                         |   7 +
 README.md                            |  11 ++
 docs/cli.html                        |   5 +-
 link.py                              | 125 ++++++++++++-
 mcp_package/link_core/agent_hooks.py | 257 +++++++++++++++++++++++++++
 mcp_package/link_core/cli_parser.py  |  19 ++
 mcp_package/link_core/cli_runtime.py |  68 +++++++
 scripts/check_tool_contract.py       |   1 +
 tests/test_agent_hooks_core.py       | 176 ++++++++++++++++++
 tests/test_link_cli.py               | 120 +++++++++++++
 10 files changed, 787 insertions(+), 2 deletions(-)
 create mode 100644 mcp_package/link_core/agent_hooks.py
 create mode 100644 tests/test_agent_hooks_core.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2ecc61e9..dfabe025 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,13 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 
 ## [Unreleased]
 
+### Added
+
+- Added `lnk connect claude-code --hooks` to install agent session hooks alongside MCP config: every new Claude Code session starts with a bounded Link memory brief injected automatically, and session end stores proposal-only session notes with memory candidates, so the memory loop no longer depends on the agent remembering to call Link.
+- Added `lnk hook session-start` to print the bounded session-start memory brief (readiness, relevant memories with confidence, pending review and capture state, and retrieval guidance) for agent hook runtimes; it scopes the brief to the hook's working directory project and never fails the agent session.
+- Added `lnk hook session-end` to turn an agent transcript into review-gated memory: it extracts bounded user/assistant text (skipping tool calls and outputs), skips trivial sessions, and stores proposal-only session notes through the same duplicate/conflict-safe capture path as `lnk session-end`.
+- Added idempotent, non-destructive session-hook writing to `~/.claude/settings.json` that preserves existing user hooks and settings, replaces only Link's own hook entries on rerun, and skips re-injection on session resume.
+
 ## [1.5.0] - 2026-07-03
 
 ### Added
diff --git a/README.md b/README.md
index a965dd4d..516d2cc3 100644
--- a/README.md
+++ b/README.md
@@ -320,6 +320,17 @@ lnk connect kiro ~/link --write
 lnk verify-mcp ~/link
 ```
 
+For Claude Code, add `--hooks` to make the memory loop automatic: session
+hooks inject a bounded Link memory brief at the start of every new session and
+store proposal-only session notes at session end, so memory no longer depends
+on the agent remembering to call Link. Durable memory still requires explicit
+review and approval.
+
+```bash
+lnk connect claude-code ~/link --hooks
+lnk connect claude-code ~/link --hooks --write
+```
+
 <details>
 <summary>MCP-only install</summary>
 
diff --git a/docs/cli.html b/docs/cli.html
index cd6cf06e..c7d427e7 100644
--- a/docs/cli.html
+++ b/docs/cli.html
@@ -129,7 +129,9 @@ <h2 id="maintenance">Maintenance</h2>
         <pre><code>lnk connect codex ~/link
 lnk connect codex ~/link --write
 lnk connect kiro ~/link --write
+lnk connect claude-code ~/link --hooks --write
 lnk verify-mcp ~/link</code></pre>
+        <p>Add <code>--hooks</code> (Claude Code) to also install session hooks: every new session then starts with a bounded Link memory brief injected automatically, and session end stores proposal-only notes with memory candidates for later review — no durable memory is written without approval. The hooks run <code>lnk hook session-start</code> and <code>lnk hook session-end</code>, which you can also invoke directly to inspect what they inject or capture.</p>
         <p>From a source checkout, use the synthetic large-wiki smoke when you want local scale evidence without touching your real wiki. The script prints the exact <code>lnk serve</code> command and graph URL for the generated fixture.</p>
         <pre><code>python3 scripts/smoke_large_wiki.py --pages 10000</code></pre>
 
@@ -188,7 +190,8 @@ <h2 id="all">All Commands</h2>
 lnk rebuild-index
 lnk rebuild-backlinks
 lnk verify-mcp [--json]
-lnk connect &lt;agent&gt; [dir] [--write] [--config path] [--python python]
+lnk connect &lt;agent&gt; [dir] [--write] [--config path] [--python python] [--hooks]
+lnk hook session-start|session-end [dir] [--limit N] [--project slug]
 lnk backup [--list] [--include-raw]
 lnk restore-backup &lt;backup.tar.gz&gt; [--include-raw] --confirm
 python3 link.py demo
diff --git a/link.py b/link.py
index 592b2847..b1c3b932 100644
--- a/link.py
+++ b/link.py
@@ -261,6 +261,12 @@
     build_mcp_connect_payload as _core_build_mcp_connect_payload,
     supported_agents as _core_supported_agents,
 )
+from link_core.agent_hooks import (
+    build_agent_hooks_payload as _core_build_agent_hooks_payload,
+    extract_transcript_text as _core_extract_transcript_text,
+    hook_supported_agents as _core_hook_supported_agents,
+    supports_agent_hooks as _core_supports_agent_hooks,
+)
 from link_core.obsidian import (
     import_obsidian_vault as _core_import_obsidian_vault,
     render_import_obsidian_text as _core_render_import_obsidian_text,
@@ -289,9 +295,11 @@
     render_query_text as _core_render_query_text,
 )
 from link_core.cli_runtime import (
+    render_agent_hooks_text as _core_render_agent_hooks_text,
     render_demo_text as _core_render_demo_text,
     render_init_text as _core_render_init_text,
     render_mcp_connect_text as _core_render_mcp_connect_text,
+    render_session_start_hook_text as _core_render_session_start_hook_text,
     render_onboard_text as _core_render_onboard_text,
     render_proof_text as _core_render_proof_text,
     render_start_text as _core_render_start_text,
@@ -1945,6 +1953,93 @@ def start(
     return code
 
 
+def _read_hook_stdin() -> dict[str, object]:
+    """Read the agent hook event JSON from stdin, if one was piped in."""
+    if sys.stdin is None or sys.stdin.isatty():
+        return {}
+    try:
+        raw = sys.stdin.read()
+    except OSError:
+        return {}
+    if not raw.strip():
+        return {}
+    try:
+        payload = json.loads(raw)
+    except (json.JSONDecodeError, ValueError):
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _hook_session_start(target: Path, hook_event: dict[str, object], limit: int, project: str | None) -> int:
+    wiki_dir = _resolve_wiki_dir(target)
+    if not wiki_dir.exists():
+        print(f"Link: wiki missing at {wiki_dir}; run {_display_command(['lnk', 'init', str(target)])} to restore it.")
+        return 0
+    project_name = project
+    if not project_name:
+        hook_cwd = str(hook_event.get("cwd") or "").strip()
+        if hook_cwd:
+            project_name = _default_project(Path(hook_cwd))
+    if not project_name:
+        project_name = _default_project(target)
+    status_payload = _core_link_status(wiki_dir, version=LINK_VERSION, include_validation=False)
+    brief_payload = _memory_brief(wiki_dir, query="", limit=limit, project=project_name)
+    brief_payload = _core_add_capture_review_to_brief(
+        brief_payload,
+        _capture_review_summary(target, project=project_name),
+    )
+    relevant_count = int(brief_payload.get("relevant_count") or len(brief_payload.get("relevant_memories") or []))
+    project_seed_recommended = bool(status_payload.get("ready")) and not relevant_count and not int(
+        status_payload.get("content_page_count") or 0
+    )
+    _, brief_text = _core_render_brief_text(brief_payload, query="", project=project_name)
+    _, text = _core_render_session_start_hook_text({
+        "target": str(target),
+        "project": project_name,
+        "status": status_payload,
+        "brief_text": brief_text,
+        "project_seed_recommended": project_seed_recommended,
+    })
+    print(text)
+    return 0
+
+
+def _hook_session_end(target: Path, hook_event: dict[str, object], limit: int, project: str | None) -> int:
+    transcript_value = str(hook_event.get("transcript_path") or "").strip()
+    if not transcript_value:
+        return 0
+    notes = _core_extract_transcript_text(Path(transcript_value).expanduser())
+    if len(notes.strip()) < 200:
+        return 0
+    project_name = project
+    if not project_name:
+        hook_cwd = str(hook_event.get("cwd") or "").strip()
+        if hook_cwd:
+            project_name = _default_project(Path(hook_cwd))
+    return session_end(
+        target,
+        notes,
+        title="Agent session notes",
+        limit=max(1, min(limit, 10)),
+        project=project_name,
+    )
+
+
+def run_agent_hook(target: Path, event: str, limit: int = 5, project: str | None = None) -> int:
+    """Run an installed agent session hook; never fail the agent session."""
+    target = target.expanduser().resolve()
+    hook_event = _read_hook_stdin()
+    try:
+        if event == "session-start":
+            return _hook_session_start(target, hook_event, limit, project)
+        if event == "session-end":
+            return _hook_session_end(target, hook_event, limit, project)
+        print(f"Unknown hook event: {event}", file=sys.stderr)
+    except Exception as exc:
+        print(f"Link {event} hook failed: {exc}", file=sys.stderr)
+    return 0
+
+
 def profile(target: Path, limit: int = 10, project: str | None = None, json_output: bool = False) -> int:
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
@@ -2042,10 +2137,15 @@ def connect_mcp(
     write: bool = False,
     config_path: str | None = None,
     python_cmd: str | None = None,
+    hooks: bool = False,
     json_output: bool = False,
 ) -> int:
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
+    if hooks and not _core_supports_agent_hooks(agent):
+        supported = ", ".join(_core_hook_supported_agents())
+        print(f"--hooks is not supported for {agent}. Session hooks are available for: {supported}", file=sys.stderr)
+        return 1
     payload = _core_build_mcp_connect_payload(
         target=target,
         wiki_dir=wiki_dir,
@@ -2057,14 +2157,36 @@ def connect_mcp(
         config_path=config_path,
         write=write,
     )
+    hooks_payload: dict[str, object] | None = None
+    if hooks:
+        runtime_script = target / "link.py"
+        if not runtime_script.exists():
+            runtime_script = ROOT / "link.py"
+        hooks_payload = _core_build_agent_hooks_payload(
+            target=target,
+            agent=agent,
+            runtime_script=runtime_script,
+            python_cmd=sys.executable,
+            write=write,
+        )
+        payload["session_hooks"] = hooks_payload
 
     if json_output:
         print(json.dumps(payload, indent=2))
         write_status = payload.get("write") if isinstance(payload.get("write"), dict) else {}
-        return 0 if not write or bool(write_status.get("ok")) else 1
+        ok = not write or bool(write_status.get("ok"))
+        if write and hooks_payload is not None:
+            hooks_write = hooks_payload.get("write") if isinstance(hooks_payload.get("write"), dict) else {}
+            ok = ok and bool(hooks_write.get("ok"))
+        return 0 if ok else 1
 
     code, text = _core_render_mcp_connect_text(payload)
     _print_text(text)
+    if hooks_payload is not None:
+        hooks_code, hooks_text = _core_render_agent_hooks_text(hooks_payload)
+        print()
+        _print_text(hooks_text)
+        code = code or hooks_code
     return code
 
 
@@ -2659,6 +2781,7 @@ def main(argv: list[str] | None = None) -> int:
             "benchmark": benchmark,
             "brief": brief,
             "start": start,
+            "hook": run_agent_hook,
             "profile": profile,
             "wins": memory_wins,
             "memory-audit": memory_audit,
diff --git a/mcp_package/link_core/agent_hooks.py b/mcp_package/link_core/agent_hooks.py
new file mode 100644
index 00000000..df1b0289
--- /dev/null
+++ b/mcp_package/link_core/agent_hooks.py
@@ -0,0 +1,257 @@
+"""Agent session-hook configuration helpers for Link.
+
+Hooks let supported agents run the Link memory loop automatically:
+a session-start hook injects a bounded memory brief into new sessions,
+and a session-end hook stores proposal-only session notes for review.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .files import atomic_write_json
+from .mcp_verify import display_command
+
+SESSION_START_TIMEOUT_SECONDS = 30
+SESSION_END_TIMEOUT_SECONDS = 60
+
+_HOOK_SCRIPT_MARKER = "link.py"
+
+
+@dataclass(frozen=True)
+class AgentHookConfig:
+    name: str
+    display_name: str
+    aliases: tuple[str, ...]
+    default_settings: str
+    start_event: str = "SessionStart"
+    end_event: str = "SessionEnd"
+    # Skip "resume": the resumed context already carries the earlier brief.
+    start_matcher: str = "startup|clear|compact"
+    restart_hint: str = "Restart the agent; new sessions will start with the Link memory brief."
+
+
+HOOK_AGENT_CONFIGS: tuple[AgentHookConfig, ...] = (
+    AgentHookConfig(
+        name="claude-code",
+        display_name="Claude Code",
+        aliases=("claude-code", "claude", "claude-code-cli"),
+        default_settings="~/.claude/settings.json",
+    ),
+)
+
+
+def hook_supported_agents() -> tuple[str, ...]:
+    """Return canonical agent names that support `lnk connect --hooks`."""
+    return tuple(config.name for config in HOOK_AGENT_CONFIGS)
+
+
+def _find_hook_agent(agent: str) -> AgentHookConfig | None:
+    normalized = agent.strip().lower().replace("_", "-")
+    for config in HOOK_AGENT_CONFIGS:
+        if normalized == config.name or normalized in config.aliases:
+            return config
+    return None
+
+
+def supports_agent_hooks(agent: str) -> bool:
+    return _find_hook_agent(agent) is not None
+
+
+def _hook_agent_by_name(agent: str) -> AgentHookConfig:
+    config = _find_hook_agent(agent)
+    if config is not None:
+        return config
+    choices = ", ".join(hook_supported_agents())
+    raise ValueError(f"session hooks are not supported for agent: {agent}. Try one of: {choices}")
+
+
+def _settings_path(default_settings: str, override: str | None) -> Path:
+    path = Path(override or default_settings).expanduser()
+    if not path.is_absolute():
+        path = (Path.cwd() / path).resolve()
+    return path
+
+
+def _hook_command(python_cmd: str, runtime_script: Path, event: str, target: Path) -> str:
+    return display_command([python_cmd, str(runtime_script), "hook", event, str(target)])
+
+
+def _hook_entry(command: str, timeout: int) -> dict[str, object]:
+    return {"type": "command", "command": command, "timeout": timeout}
+
+
+def _is_link_hook_command(command: object, event: str) -> bool:
+    if not isinstance(command, str):
+        return False
+    return _HOOK_SCRIPT_MARKER in command and f" hook {event}" in command
+
+
+def _merge_hook_event(
+    settings: dict[str, Any],
+    event_name: str,
+    event: str,
+    entry: dict[str, object],
+    matcher: str | None = None,
+) -> None:
+    hooks = settings.get("hooks")
+    if not isinstance(hooks, dict):
+        hooks = {}
+        settings["hooks"] = hooks
+    groups = hooks.get(event_name)
+    if not isinstance(groups, list):
+        groups = []
+    replaced = False
+    for group in groups:
+        if not isinstance(group, dict):
+            continue
+        group_hooks = group.get("hooks")
+        if not isinstance(group_hooks, list):
+            continue
+        for index, existing in enumerate(group_hooks):
+            if isinstance(existing, dict) and _is_link_hook_command(existing.get("command"), event):
+                group_hooks[index] = dict(entry)
+                replaced = True
+    if not replaced:
+        group: dict[str, object] = {"hooks": [dict(entry)]}
+        if matcher:
+            group["matcher"] = matcher
+        groups.append(group)
+    hooks[event_name] = groups
+
+
+def _hooks_snippet(config: AgentHookConfig, start_entry: dict[str, object], end_entry: dict[str, object]) -> str:
+    return json.dumps(
+        {
+            "hooks": {
+                config.start_event: [{"matcher": config.start_matcher, "hooks": [start_entry]}],
+                config.end_event: [{"hooks": [end_entry]}],
+            }
+        },
+        indent=2,
+    )
+
+
+def _write_hooks(
+    path: Path,
+    config: AgentHookConfig,
+    start_entry: dict[str, object],
+    end_entry: dict[str, object],
+) -> None:
+    settings: dict[str, Any] = {}
+    if path.exists() and path.read_text(encoding="utf-8", errors="replace").strip():
+        settings = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+        if not isinstance(settings, dict):
+            raise ValueError(f"{path} must contain a JSON object")
+    _merge_hook_event(settings, config.start_event, "session-start", start_entry, matcher=config.start_matcher)
+    _merge_hook_event(settings, config.end_event, "session-end", end_entry)
+    atomic_write_json(path, settings)
+
+
+def build_agent_hooks_payload(
+    *,
+    target: Path,
+    agent: str,
+    runtime_script: Path,
+    python_cmd: str,
+    settings_path: str | None = None,
+    write: bool = False,
+) -> dict[str, object]:
+    """Build or write session-hook configuration for a supported local agent."""
+    config = _hook_agent_by_name(agent)
+    path = _settings_path(config.default_settings, settings_path)
+    start_command = _hook_command(python_cmd, runtime_script, "session-start", target)
+    end_command = _hook_command(python_cmd, runtime_script, "session-end", target)
+    start_entry = _hook_entry(start_command, SESSION_START_TIMEOUT_SECONDS)
+    end_entry = _hook_entry(end_command, SESSION_END_TIMEOUT_SECONDS)
+    write_status: dict[str, object] = {"requested": write, "ok": False, "message": "preview only"}
+    if write:
+        try:
+            _write_hooks(path, config, start_entry, end_entry)
+            write_status = {"requested": True, "ok": True, "message": f"updated {path}"}
+        except Exception as exc:
+            write_status = {"requested": True, "ok": False, "message": str(exc)}
+
+    return {
+        "agent": config.name,
+        "display_name": config.display_name,
+        "target": str(target),
+        "settings_path": str(path),
+        "events": {
+            config.start_event: start_command,
+            config.end_event: end_command,
+        },
+        "snippet": _hooks_snippet(config, start_entry, end_entry),
+        "write": write_status,
+        "behavior": [
+            f"{config.start_event}: injects a bounded Link memory brief into new agent sessions.",
+            f"{config.end_event}: stores proposal-only session notes locally; durable memory still requires review.",
+        ],
+        "restart_hint": config.restart_hint,
+    }
+
+
+def _content_text(content: object) -> str:
+    if isinstance(content, str):
+        return content.strip()
+    parts: list[str] = []
+    if isinstance(content, list):
+        for block in content:
+            if isinstance(block, dict) and block.get("type") == "text":
+                text = block.get("text")
+                if isinstance(text, str) and text.strip():
+                    parts.append(text.strip())
+    return "\n".join(parts)
+
+
+def extract_transcript_text(
+    transcript_path: Path,
+    *,
+    max_chars: int = 6000,
+    max_message_chars: int = 800,
+) -> str:
+    """Extract bounded conversation text from an agent transcript JSONL file.
+
+    Keeps user and assistant text blocks, skips tool calls/results and meta
+    entries, and returns the most recent messages within `max_chars`.
+    """
+    try:
+        raw = transcript_path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return ""
+    lines: list[str] = []
+    for line in raw.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            entry = json.loads(line)
+        except (json.JSONDecodeError, ValueError):
+            continue
+        if not isinstance(entry, dict) or entry.get("isMeta"):
+            continue
+        if entry.get("type") not in {"user", "assistant"}:
+            continue
+        message = entry.get("message")
+        if not isinstance(message, dict):
+            continue
+        text = _content_text(message.get("content"))
+        if not text:
+            continue
+        if len(text) > max_message_chars:
+            text = text[: max_message_chars].rstrip() + " …"
+        role = "User" if entry.get("type") == "user" else "Assistant"
+        lines.append(f"{role}: {text}")
+    if not lines:
+        return ""
+    kept: list[str] = []
+    total = 0
+    for line in reversed(lines):
+        cost = len(line) + 2
+        if kept and total + cost > max_chars:
+            break
+        kept.append(line)
+        total += cost
+    return "\n\n".join(reversed(kept))
diff --git a/mcp_package/link_core/cli_parser.py b/mcp_package/link_core/cli_parser.py
index 3fc97273..e5eb3a8d 100644
--- a/mcp_package/link_core/cli_parser.py
+++ b/mcp_package/link_core/cli_parser.py
@@ -304,6 +304,12 @@ def build_cli_parser(
     start_cmd.add_argument("--project", default=None, help="include user/global memories plus this project's memories")
     start_cmd.add_argument("--json", action="store_true", help="print machine-readable startup packet")
 
+    hook_cmd = sub.add_parser("hook", help="run an agent session hook (invoked by installed agent hooks)")
+    hook_cmd.add_argument("event", choices=["session-start", "session-end"], help="agent session lifecycle event")
+    hook_cmd.add_argument("target", nargs="?", default=".")
+    hook_cmd.add_argument("--limit", type=int, default=5, help="maximum memories in the session-start brief")
+    hook_cmd.add_argument("--project", default=None, help="include user/global memories plus this project's memories")
+
     profile_cmd = sub.add_parser("profile", help="show what Link remembers")
     profile_cmd.add_argument("target", nargs="?", default=".")
     profile_cmd.add_argument("--limit", type=int, default=10)
@@ -380,6 +386,11 @@ def build_cli_parser(
     connect_cmd.add_argument("--write", action="store_true", help="update the detected agent config file")
     connect_cmd.add_argument("--config", default=None, help="override the agent config file path")
     connect_cmd.add_argument("--python", default=None, help="Python executable for the MCP server")
+    connect_cmd.add_argument(
+        "--hooks",
+        action="store_true",
+        help="also configure session hooks so new sessions start with the Link brief (Claude Code)",
+    )
     connect_cmd.add_argument("--json", action="store_true", help="print machine-readable connection plan")
 
     return parser
@@ -655,6 +666,13 @@ def dispatch_cli_command(args: Any, handlers: Mapping[str, CliHandler]) -> int:
             project=args.project,
             json_output=args.json,
         )
+    if command == "hook":
+        return handlers["hook"](
+            Path(args.target),
+            args.event,
+            limit=args.limit,
+            project=args.project,
+        )
     if command == "profile":
         return handlers["profile"](Path(args.target), limit=args.limit, project=args.project, json_output=args.json)
     if command == "wins":
@@ -699,6 +717,7 @@ def dispatch_cli_command(args: Any, handlers: Mapping[str, CliHandler]) -> int:
             write=args.write,
             config_path=args.config,
             python_cmd=args.python,
+            hooks=args.hooks,
             json_output=args.json,
         )
     raise ValueError(f"unknown command: {command}")
diff --git a/mcp_package/link_core/cli_runtime.py b/mcp_package/link_core/cli_runtime.py
index a48392f3..0db55542 100644
--- a/mcp_package/link_core/cli_runtime.py
+++ b/mcp_package/link_core/cli_runtime.py
@@ -464,3 +464,71 @@ def render_mcp_connect_text(payload: Mapping[str, object]) -> tuple[int, str]:
     if restart_hint:
         lines.append(f"  {restart_hint}")
     return code, "\n".join(lines)
+
+
+def render_agent_hooks_text(payload: Mapping[str, object]) -> tuple[int, str]:
+    """Render a session-hook configuration plan for a supported local agent."""
+    write_status = payload.get("write") if isinstance(payload.get("write"), Mapping) else {}
+    requested = bool(write_status.get("requested"))
+    ok = bool(write_status.get("ok"))
+    code = 0 if not requested or ok else 1
+    lines = [
+        f"Link session hooks: {payload.get('display_name')}",
+        "",
+        f"Settings: {payload.get('settings_path')}",
+    ]
+    behavior = payload.get("behavior")
+    if isinstance(behavior, Sequence) and not isinstance(behavior, (str, bytes)):
+        lines.append("")
+        lines.extend(f"  {item}" for item in behavior)
+    lines.append("")
+    if requested:
+        lines.append(f"Write: {'updated' if ok else 'failed'}")
+        message = write_status.get("message")
+        if message:
+            lines.append(f"  {message}")
+    else:
+        lines.append("Preview only. Rerun with --write to update the settings file.")
+    lines.extend(["", "Hooks snippet:"])
+    snippet = str(payload.get("snippet") or "")
+    lines.extend(f"  {line}" if line else "" for line in snippet.splitlines())
+    restart_hint = payload.get("restart_hint")
+    if restart_hint:
+        lines.extend(["", f"  {restart_hint}"])
+    return code, "\n".join(lines)
+
+
+def render_session_start_hook_text(payload: Mapping[str, object]) -> tuple[int, str]:
+    """Render the bounded memory-brief context block injected by session-start hooks."""
+    status = payload.get("status") if isinstance(payload.get("status"), Mapping) else {}
+    target = str(payload.get("target") or "")
+    project = str(payload.get("project") or "").strip()
+    lines = [
+        "Link memory (local, source-backed)"
+        + (f" · project {project}" if project else ""),
+    ]
+    if not status.get("ready"):
+        lines.extend([
+            "Link is not ready; skipping the memory brief.",
+            f"Check with: {display_command(['lnk', 'health', target])}",
+        ])
+        return 0, "\n".join(lines)
+
+    brief_text = str(payload.get("brief_text") or "").strip()
+    if brief_text:
+        lines.extend(["", brief_text])
+
+    seed_recommended = bool(payload.get("project_seed_recommended"))
+    if seed_recommended:
+        lines.extend([
+            "",
+            "No project context or relevant memory yet. To seed source-backed project context "
+            f"from this repo's docs, suggest: {display_command(['lnk', 'seed', '.', target])}",
+        ])
+    lines.extend([
+        "",
+        "Use this brief before asking the user to repeat durable context. "
+        f"For task-specific context: {display_command(['lnk', 'query', '<topic>', target, '--budget', 'micro'])} "
+        "or the Link MCP recall tool. Save durable memory only after explicit user approval.",
+    ])
+    return 0, "\n".join(lines)
diff --git a/scripts/check_tool_contract.py b/scripts/check_tool_contract.py
index d37d74e0..27744d81 100644
--- a/scripts/check_tool_contract.py
+++ b/scripts/check_tool_contract.py
@@ -26,6 +26,7 @@
     "forget-memory",
     "graph-summary",
     "health",
+    "hook",
     "import-obsidian",
     "ingest-status",
     "init",
diff --git a/tests/test_agent_hooks_core.py b/tests/test_agent_hooks_core.py
new file mode 100644
index 00000000..4081994a
--- /dev/null
+++ b/tests/test_agent_hooks_core.py
@@ -0,0 +1,176 @@
+import json
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "mcp_package"))
+
+from link_core.agent_hooks import (  # noqa: E402
+    build_agent_hooks_payload,
+    extract_transcript_text,
+    hook_supported_agents,
+    supports_agent_hooks,
+)
+
+
+def _transcript_line(role: str, content: object) -> str:
+    return json.dumps({"type": role, "message": {"role": role, "content": content}})
+
+
+class AgentHooksCoreTests(unittest.TestCase):
+    def test_hook_supported_agents_include_claude_code(self):
+        self.assertIn("claude-code", hook_supported_agents())
+
+    def test_supports_agent_hooks_accepts_aliases_and_rejects_others(self):
+        self.assertTrue(supports_agent_hooks("claude-code"))
+        self.assertTrue(supports_agent_hooks("claude"))
+        self.assertFalse(supports_agent_hooks("codex"))
+        self.assertFalse(supports_agent_hooks("cursor"))
+
+    def test_build_payload_rejects_unsupported_agent(self):
+        with self.assertRaises(ValueError):
+            build_agent_hooks_payload(
+                target=Path("/tmp/link"),
+                agent="codex",
+                runtime_script=Path("/tmp/link/link.py"),
+                python_cmd="python3",
+            )
+
+    def test_build_preview_includes_both_events_and_commands(self):
+        payload = build_agent_hooks_payload(
+            target=Path("/tmp/my link"),
+            agent="claude-code",
+            runtime_script=Path("/tmp/my link/link.py"),
+            python_cmd="/usr/bin/python3",
+        )
+
+        self.assertEqual(payload["agent"], "claude-code")
+        self.assertFalse(payload["write"]["ok"])
+        events = payload["events"]
+        self.assertIn(" hook session-start ", str(events["SessionStart"]))
+        self.assertIn(" hook session-end ", str(events["SessionEnd"]))
+        # Paths with spaces must stay shell-safe in the written command.
+        self.assertIn("'/tmp/my link/link.py'", str(events["SessionStart"]))
+        snippet = json.loads(str(payload["snippet"]))
+        self.assertIn("SessionStart", snippet["hooks"])
+        self.assertIn("SessionEnd", snippet["hooks"])
+        self.assertEqual(snippet["hooks"]["SessionStart"][0]["matcher"], "startup|clear|compact")
+
+    def test_write_preserves_existing_settings_and_hooks(self):
+        with tempfile.TemporaryDirectory() as temp:
+            settings = Path(temp) / "settings.json"
+            settings.write_text(
+                json.dumps({
+                    "model": "opus",
+                    "hooks": {
+                        "PreToolUse": [{"matcher": "Bash", "hooks": [{"type": "command", "command": "my-guard"}]}],
+                        "SessionStart": [{"hooks": [{"type": "command", "command": "echo user-hook"}]}],
+                    },
+                }),
+                encoding="utf-8",
+            )
+
+            payload = build_agent_hooks_payload(
+                target=Path(temp),
+                agent="claude-code",
+                runtime_script=Path(temp) / "link.py",
+                python_cmd="python3",
+                settings_path=str(settings),
+                write=True,
+            )
+
+            self.assertTrue(payload["write"]["ok"], payload["write"])
+            data = json.loads(settings.read_text(encoding="utf-8"))
+            self.assertEqual(data["model"], "opus")
+            self.assertEqual(data["hooks"]["PreToolUse"][0]["hooks"][0]["command"], "my-guard")
+            self.assertEqual(data["hooks"]["SessionStart"][0]["hooks"][0]["command"], "echo user-hook")
+            start_groups = data["hooks"]["SessionStart"]
+            self.assertEqual(len(start_groups), 2)
+            self.assertEqual(start_groups[1]["matcher"], "startup|clear|compact")
+            self.assertEqual(len(data["hooks"]["SessionEnd"]), 1)
+
+    def test_rewrite_is_idempotent(self):
+        with tempfile.TemporaryDirectory() as temp:
+            settings = Path(temp) / "settings.json"
+            for _ in range(2):
+                payload = build_agent_hooks_payload(
+                    target=Path(temp),
+                    agent="claude-code",
+                    runtime_script=Path(temp) / "link.py",
+                    python_cmd="python3",
+                    settings_path=str(settings),
+                    write=True,
+                )
+                self.assertTrue(payload["write"]["ok"], payload["write"])
+
+            data = json.loads(settings.read_text(encoding="utf-8"))
+            self.assertEqual(len(data["hooks"]["SessionStart"]), 1)
+            self.assertEqual(len(data["hooks"]["SessionStart"][0]["hooks"]), 1)
+            self.assertEqual(len(data["hooks"]["SessionEnd"]), 1)
+            self.assertEqual(len(data["hooks"]["SessionEnd"][0]["hooks"]), 1)
+
+    def test_write_refuses_non_object_settings_file(self):
+        with tempfile.TemporaryDirectory() as temp:
+            settings = Path(temp) / "settings.json"
+            settings.write_text("[]", encoding="utf-8")
+
+            payload = build_agent_hooks_payload(
+                target=Path(temp),
+                agent="claude-code",
+                runtime_script=Path(temp) / "link.py",
+                python_cmd="python3",
+                settings_path=str(settings),
+                write=True,
+            )
+
+            self.assertFalse(payload["write"]["ok"])
+            self.assertEqual(settings.read_text(encoding="utf-8"), "[]")
+
+    def test_extract_transcript_keeps_text_and_skips_tool_blocks(self):
+        with tempfile.TemporaryDirectory() as temp:
+            transcript = Path(temp) / "transcript.jsonl"
+            transcript.write_text(
+                "\n".join([
+                    _transcript_line("user", "We decided to use SQLite FTS."),
+                    _transcript_line("assistant", [
+                        {"type": "text", "text": "Noted the SQLite FTS decision."},
+                        {"type": "tool_use", "id": "x", "name": "Bash", "input": {"command": "secret-tool-call"}},
+                    ]),
+                    _transcript_line("user", [
+                        {"type": "tool_result", "tool_use_id": "x", "content": "tool output noise"},
+                    ]),
+                    json.dumps({"type": "summary", "summary": "meta line"}),
+                    "not json at all",
+                ]),
+                encoding="utf-8",
+            )
+
+            text = extract_transcript_text(transcript)
+
+        self.assertIn("User: We decided to use SQLite FTS.", text)
+        self.assertIn("Assistant: Noted the SQLite FTS decision.", text)
+        self.assertNotIn("secret-tool-call", text)
+        self.assertNotIn("tool output noise", text)
+        self.assertNotIn("meta line", text)
+
+    def test_extract_transcript_bounds_output_to_most_recent_messages(self):
+        with tempfile.TemporaryDirectory() as temp:
+            transcript = Path(temp) / "transcript.jsonl"
+            lines = [_transcript_line("user", f"message {index}: " + ("x" * 400)) for index in range(50)]
+            transcript.write_text("\n".join(lines), encoding="utf-8")
+
+            text = extract_transcript_text(transcript, max_chars=2000)
+
+        self.assertLessEqual(len(text), 2200)
+        self.assertIn("message 49", text)
+        self.assertNotIn("message 0:", text)
+
+    def test_extract_transcript_handles_missing_file(self):
+        self.assertEqual(extract_transcript_text(Path("/nonexistent/transcript.jsonl")), "")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_link_cli.py b/tests/test_link_cli.py
index 17efecc8..79deec60 100644
--- a/tests/test_link_cli.py
+++ b/tests/test_link_cli.py
@@ -2775,5 +2775,125 @@ def test_doctor_fails_on_service_account_filename(self):
         self.assertIn("service-account-prod.json", out.getvalue())
 
 
+class AgentHookCliTests(unittest.TestCase):
+    def _hook_stdin(self, payload: dict) -> StringIO:
+        return StringIO(json.dumps(payload))
+
+    def test_hook_session_start_prints_memory_brief(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+
+        out = StringIO()
+        with patch("sys.stdin", self._hook_stdin({"cwd": str(tmp), "source": "startup"})):
+            with redirect_stdout(out):
+                code = link_cli.run_agent_hook(target, "session-start")
+
+        self.assertEqual(code, 0)
+        text = out.getvalue()
+        self.assertIn("Link memory (local, source-backed)", text)
+        self.assertIn("Relevant memories", text)
+        self.assertIn("Save durable memory only after explicit user approval.", text)
+
+    def test_hook_session_start_missing_wiki_exits_zero_with_guidance(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "missing"
+
+        out = StringIO()
+        with patch("sys.stdin", self._hook_stdin({"source": "startup"})):
+            with redirect_stdout(out):
+                code = link_cli.run_agent_hook(target, "session-start")
+
+        self.assertEqual(code, 0)
+        self.assertIn("wiki missing", out.getvalue())
+
+    def test_hook_session_end_captures_proposal_only_notes(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+        transcript = tmp / "transcript.jsonl"
+        transcript.write_text(
+            "\n".join(
+                json.dumps({
+                    "type": "user",
+                    "message": {
+                        "role": "user",
+                        "content": f"Decision {index}: we keep agent memory in reviewable local Markdown pages.",
+                    },
+                })
+                for index in range(6)
+            ),
+            encoding="utf-8",
+        )
+
+        out = StringIO()
+        with patch("sys.stdin", self._hook_stdin({"cwd": str(tmp), "transcript_path": str(transcript)})):
+            with redirect_stdout(out):
+                code = link_cli.run_agent_hook(target, "session-end")
+
+        self.assertEqual(code, 0)
+        captures = list((target / "raw/memory-captures").glob("*agent-session-notes*.md"))
+        self.assertEqual(len(captures), 1)
+        self.assertIn("proposal-only", out.getvalue())
+
+    def test_hook_session_end_skips_trivial_sessions(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+        transcript = tmp / "transcript.jsonl"
+        transcript.write_text(
+            json.dumps({"type": "user", "message": {"role": "user", "content": "hi"}}),
+            encoding="utf-8",
+        )
+
+        out = StringIO()
+        with patch("sys.stdin", self._hook_stdin({"transcript_path": str(transcript)})):
+            with redirect_stdout(out):
+                code = link_cli.run_agent_hook(target, "session-end")
+
+        self.assertEqual(code, 0)
+        captures = list((target / "raw/memory-captures").glob("*agent-session-notes*.md"))
+        self.assertEqual(captures, [])
+
+    def test_hook_session_end_without_stdin_payload_is_noop(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+
+        with patch("sys.stdin", StringIO("")):
+            code = link_cli.run_agent_hook(target, "session-end")
+
+        self.assertEqual(code, 0)
+
+    def test_connect_hooks_rejects_unsupported_agent(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+
+        err = StringIO()
+        with redirect_stderr(err):
+            code = link_cli.connect_mcp(target, "codex", hooks=True)
+
+        self.assertEqual(code, 1)
+        self.assertIn("--hooks is not supported for codex", err.getvalue())
+
+    def test_connect_hooks_preview_includes_session_hooks_payload(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+
+        out = StringIO()
+        with redirect_stdout(out):
+            code = link_cli.connect_mcp(target, "claude-code", hooks=True, json_output=True)
+
+        self.assertEqual(code, 0)
+        payload = json.loads(out.getvalue())
+        session_hooks = payload["session_hooks"]
+        self.assertEqual(session_hooks["agent"], "claude-code")
+        self.assertFalse(session_hooks["write"]["ok"])
+        self.assertIn(" hook session-start ", session_hooks["events"]["SessionStart"])
+        self.assertIn(str(target / "link.py"), session_hooks["events"]["SessionStart"])
+
+
 if __name__ == "__main__":
     unittest.main()

From bb1677adc815f2edd8bb6fc08d5605334a35079f Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Tue, 7 Jul 2026 23:21:56 -0600
Subject: [PATCH 02/25] Extend session hooks to Codex and Cursor; add
 review-gated consolidation loop

- lnk connect --hooks now supports Codex (~/.codex/hooks.json, nested schema,
  session-start only: Codex has no session-end event) and Cursor
  (~/.cursor/hooks.json, flat version-1 schema, JSON additional_context
  envelope via lnk hook --emit cursor), alongside Claude Code.
- Session-end capture noise controls: sessions with no memory-worthy
  proposal candidates are skipped and duplicate end events are deduplicated
  with a local fingerprint, so automatic hooks cannot flood the inbox.
- New lnk consolidate and MCP review(action=consolidate): a read-only backlog
  plan with pending captures, review queue, duplicate-capture groups, and
  paste-safe accept/discard commands. The injected session-start brief nudges
  the agent to offer consolidation when the backlog crosses thresholds;
  nothing is ever merged, deleted, or saved without per-action user approval.
---
 CHANGELOG.md                         |   5 +-
 README.md                            |  18 ++-
 docs/cli.html                        |   4 +-
 link.py                              | 135 ++++++++++++++++--
 mcp_package/link_core/agent_hooks.py | 195 ++++++++++++++++++++-----
 mcp_package/link_core/cli_parser.py  |  15 ++
 mcp_package/link_core/cli_runtime.py |  11 ++
 mcp_package/link_core/consolidate.py | 203 +++++++++++++++++++++++++++
 mcp_package/link_mcp/server.py       |  18 ++-
 scripts/check_tool_contract.py       |   1 +
 tests/test_agent_hooks_core.py       |  80 ++++++++++-
 tests/test_link_cli.py               | 113 ++++++++++++++-
 12 files changed, 727 insertions(+), 71 deletions(-)
 create mode 100644 mcp_package/link_core/consolidate.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index dfabe025..e83d8dfa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,7 +8,10 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 
 ### Added
 
-- Added `lnk connect claude-code --hooks` to install agent session hooks alongside MCP config: every new Claude Code session starts with a bounded Link memory brief injected automatically, and session end stores proposal-only session notes with memory candidates, so the memory loop no longer depends on the agent remembering to call Link.
+- Added `lnk connect <agent> --hooks` to install agent session hooks alongside MCP config for Claude Code, Codex, and Cursor: every new session starts with a bounded Link memory brief injected automatically, and session end stores proposal-only session notes with memory candidates, so the memory loop no longer depends on the agent remembering to call Link. Codex has no session-end hook event, so it gets the session-start brief only; Cursor uses its flat `hooks.json` schema and JSON `additional_context` envelope.
+- Added `lnk consolidate` and MCP `review(action="consolidate")` for a read-only backlog plan: pending capture counts, memories needing review, duplicate-capture groups, and paste-safe accept/discard/review commands — nothing is merged, deleted, or saved without the user approving each action.
+- Added an automatic backlog nudge to the injected session-start brief: when pending captures or review items cross a threshold, the brief tells the agent to offer the user a short consolidation pass instead of letting the inbox silently grow.
+- Added session-end capture noise controls: sessions with no memory-worthy proposal candidates are skipped entirely, and duplicate end events for the same conversation content are deduplicated with a local fingerprint, so automatic hooks cannot flood the capture inbox.
 - Added `lnk hook session-start` to print the bounded session-start memory brief (readiness, relevant memories with confidence, pending review and capture state, and retrieval guidance) for agent hook runtimes; it scopes the brief to the hook's working directory project and never fails the agent session.
 - Added `lnk hook session-end` to turn an agent transcript into review-gated memory: it extracts bounded user/assistant text (skipping tool calls and outputs), skips trivial sessions, and stores proposal-only session notes through the same duplicate/conflict-safe capture path as `lnk session-end`.
 - Added idempotent, non-destructive session-hook writing to `~/.claude/settings.json` that preserves existing user hooks and settings, replaces only Link's own hook entries on rerun, and skips re-injection on session resume.
diff --git a/README.md b/README.md
index 516d2cc3..cebf0b01 100644
--- a/README.md
+++ b/README.md
@@ -320,15 +320,21 @@ lnk connect kiro ~/link --write
 lnk verify-mcp ~/link
 ```
 
-For Claude Code, add `--hooks` to make the memory loop automatic: session
-hooks inject a bounded Link memory brief at the start of every new session and
-store proposal-only session notes at session end, so memory no longer depends
-on the agent remembering to call Link. Durable memory still requires explicit
-review and approval.
+For agents with session-hook support — Claude Code, Codex, and Cursor — add
+`--hooks` to make the memory loop automatic: session hooks inject a bounded
+Link memory brief at the start of every new session, and (where the agent has
+a session-end event) store proposal-only session notes at session end, so
+memory no longer depends on the agent remembering to call Link. Sessions with
+nothing memory-worthy are skipped, duplicate end events are deduplicated, and
+when the review backlog builds up the injected brief nudges the agent to offer
+a `lnk consolidate` pass. Durable memory still requires explicit review and
+approval; consolidation is a read-only plan.
 
 ```bash
-lnk connect claude-code ~/link --hooks
 lnk connect claude-code ~/link --hooks --write
+lnk connect codex ~/link --hooks --write    # session-start brief (Codex has no session-end event)
+lnk connect cursor ~/link --hooks --write
+lnk consolidate ~/link                      # read-only backlog plan, apply only with approval
 ```
 
 <details>
diff --git a/docs/cli.html b/docs/cli.html
index c7d427e7..3e265d4d 100644
--- a/docs/cli.html
+++ b/docs/cli.html
@@ -131,7 +131,8 @@ <h2 id="maintenance">Maintenance</h2>
 lnk connect kiro ~/link --write
 lnk connect claude-code ~/link --hooks --write
 lnk verify-mcp ~/link</code></pre>
-        <p>Add <code>--hooks</code> (Claude Code) to also install session hooks: every new session then starts with a bounded Link memory brief injected automatically, and session end stores proposal-only notes with memory candidates for later review — no durable memory is written without approval. The hooks run <code>lnk hook session-start</code> and <code>lnk hook session-end</code>, which you can also invoke directly to inspect what they inject or capture.</p>
+        <p>Add <code>--hooks</code> (Claude Code, Codex, Cursor) to also install session hooks: every new session then starts with a bounded Link memory brief injected automatically, and session end stores proposal-only notes with memory candidates for later review — no durable memory is written without approval. Codex has no session-end event, so it gets the session-start brief only. Sessions without memory-worthy content are skipped and duplicate end events are deduplicated, so the capture inbox does not fill with noise. The hooks run <code>lnk hook session-start</code> and <code>lnk hook session-end</code>, which you can also invoke directly to inspect what they inject or capture.</p>
+        <p>Use <code>lnk consolidate</code> when the capture or review backlog builds up. It is read-only: it counts pending captures and memories needing review, groups duplicate captures, and prints paste-safe accept/discard/review commands to run with the user. When the backlog crosses a threshold, the injected session-start brief nudges the agent to offer a consolidation pass, and MCP agents can request the same plan through <code>review(action="consolidate")</code>.</p>
         <p>From a source checkout, use the synthetic large-wiki smoke when you want local scale evidence without touching your real wiki. The script prints the exact <code>lnk serve</code> command and graph URL for the generated fixture.</p>
         <pre><code>python3 scripts/smoke_large_wiki.py --pages 10000</code></pre>
 
@@ -171,6 +172,7 @@ <h2 id="all">All Commands</h2>
 lnk start [dir] [--task "task"] [--project slug]
 lnk brief "task" [--project slug]
 lnk memory-audit [--project slug]
+lnk consolidate [dir] [--project slug] [--limit N]
 lnk recall "query" [--project slug]
 lnk profile [--project slug]
 lnk wins [--project slug]
diff --git a/link.py b/link.py
index b1c3b932..4fa7ea71 100644
--- a/link.py
+++ b/link.py
@@ -52,6 +52,7 @@
 """
 from __future__ import annotations
 
+import hashlib
 import json
 import os
 import shutil
@@ -267,6 +268,11 @@
     hook_supported_agents as _core_hook_supported_agents,
     supports_agent_hooks as _core_supports_agent_hooks,
 )
+from link_core.consolidate import (
+    build_consolidation_plan as _core_build_consolidation_plan,
+    memory_backlog_summary as _core_memory_backlog_summary,
+    render_consolidate_text as _core_render_consolidate_text,
+)
 from link_core.obsidian import (
     import_obsidian_vault as _core_import_obsidian_vault,
     render_import_obsidian_text as _core_render_import_obsidian_text,
@@ -1970,16 +1976,75 @@ def _read_hook_stdin() -> dict[str, object]:
     return payload if isinstance(payload, dict) else {}
 
 
-def _hook_session_start(target: Path, hook_event: dict[str, object], limit: int, project: str | None) -> int:
+def _memory_backlog_summary(target: Path, wiki_dir: Path) -> dict[str, object]:
+    """Workspace-wide backlog signal (unscoped: consolidation is a workspace chore)."""
+    root = _resolve_link_root(target)
+    captures = _capture_review_summary(target, project=None, limit=1)
+    inbox = _memory_inbox(wiki_dir, limit=50)
+    return _core_memory_backlog_summary(
+        capture_count=int(captures.get("count") or 0),
+        needs_review_count=int(inbox.get("review_count") or 0),
+        command_target=root,
+    )
+
+
+def consolidate(target: Path, limit: int = 50, project: str | None = None, json_output: bool = False) -> int:
+    """Print a read-only consolidation plan for capture and review backlogs."""
+    target = target.expanduser().resolve()
+    root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Link: wiki missing at {wiki_dir}; run {_display_command(['lnk', 'init', str(target)])} to restore it.")
+        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
+        return 1
+    captures_payload = _core_capture_inbox(
+        root,
+        limit=max(1, min(limit, 50)),
+        project=project,
+        commands_for=lambda rel_path: _core_cli_capture_commands(rel_path, root),
+    )
+    inbox_payload = _memory_inbox(wiki_dir, limit=max(1, min(limit, 50)), project=project)
+    payload = _core_build_consolidation_plan(
+        captures_payload=captures_payload,
+        inbox_payload=inbox_payload,
+        command_target=root,
+        project=project,
+    )
+    return _emit_json_or_text(payload, json_output, _core_render_consolidate_text)
+
+
+def _hook_project_dir(hook_event: dict[str, object]) -> str:
+    """Return the project directory the hook fired in, across agent schemas."""
+    hook_cwd = str(hook_event.get("cwd") or "").strip()
+    if hook_cwd:
+        return hook_cwd
+    roots = hook_event.get("workspace_roots")
+    if isinstance(roots, list) and roots and isinstance(roots[0], str) and roots[0].strip():
+        return roots[0].strip()
+    return ""
+
+
+def _emit_session_start(text: str, emit: str) -> None:
+    if emit == "cursor":
+        print(json.dumps({"additional_context": text}))
+        return
+    print(text)
+
+
+def _hook_session_start(
+    target: Path, hook_event: dict[str, object], limit: int, project: str | None, emit: str
+) -> int:
+    wiki_dir = _resolve_wiki_dir(target)
+    if not wiki_dir.exists():
+        _emit_session_start(
+            f"Link: wiki missing at {wiki_dir}; run {_display_command(['lnk', 'init', str(target)])} to restore it.",
+            emit,
+        )
         return 0
     project_name = project
     if not project_name:
-        hook_cwd = str(hook_event.get("cwd") or "").strip()
-        if hook_cwd:
-            project_name = _default_project(Path(hook_cwd))
+        project_dir = _hook_project_dir(hook_event)
+        if project_dir:
+            project_name = _default_project(Path(project_dir))
     if not project_name:
         project_name = _default_project(target)
     status_payload = _core_link_status(wiki_dir, version=LINK_VERSION, include_validation=False)
@@ -1999,11 +2064,21 @@ def _hook_session_start(target: Path, hook_event: dict[str, object], limit: int,
         "status": status_payload,
         "brief_text": brief_text,
         "project_seed_recommended": project_seed_recommended,
+        "backlog": _memory_backlog_summary(target, wiki_dir),
     })
-    print(text)
+    _emit_session_start(text, emit)
     return 0
 
 
+def _session_end_hook_state_path(target: Path) -> Path:
+    return _resolve_link_root(target) / ".link-cache" / "session-end-hook.hash"
+
+
+def _session_notes_fingerprint(notes: str) -> str:
+    normalized = " ".join(notes.split()).lower()
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
+
+
 def _hook_session_end(target: Path, hook_event: dict[str, object], limit: int, project: str | None) -> int:
     transcript_value = str(hook_event.get("transcript_path") or "").strip()
     if not transcript_value:
@@ -2011,27 +2086,60 @@ def _hook_session_end(target: Path, hook_event: dict[str, object], limit: int, p
     notes = _core_extract_transcript_text(Path(transcript_value).expanduser())
     if len(notes.strip()) < 200:
         return 0
+    # Skip duplicate firings for the same conversation content (e.g. /clear
+    # immediately followed by exit, or repeated end events).
+    state_path = _session_end_hook_state_path(target)
+    fingerprint = _session_notes_fingerprint(notes)
+    try:
+        if state_path.exists() and state_path.read_text(encoding="utf-8").strip() == fingerprint:
+            return 0
+    except OSError:
+        pass
     project_name = project
     if not project_name:
-        hook_cwd = str(hook_event.get("cwd") or "").strip()
-        if hook_cwd:
-            project_name = _default_project(Path(hook_cwd))
-    return session_end(
+        project_dir = _hook_project_dir(hook_event)
+        if project_dir:
+            project_name = _default_project(Path(project_dir))
+    # Only store a capture when the session produced memory-worthy candidates;
+    # otherwise every session would add review-inbox noise.
+    wiki_dir = _resolve_wiki_dir(target)
+    root = _resolve_link_root(target)
+    proposal_limit = max(1, min(limit, 10))
+    preview = _propose_memories_from_text(
+        wiki_dir,
+        notes,
+        source="agent-session-hook",
+        limit=proposal_limit,
+        project=project_name,
+        command_target=root,
+    )
+    if not int(preview.get("count") or 0):
+        return 0
+    code = session_end(
         target,
         notes,
         title="Agent session notes",
-        limit=max(1, min(limit, 10)),
+        limit=proposal_limit,
         project=project_name,
     )
+    if code == 0:
+        try:
+            state_path.parent.mkdir(parents=True, exist_ok=True)
+            state_path.write_text(fingerprint, encoding="utf-8")
+        except OSError:
+            pass
+    return code
 
 
-def run_agent_hook(target: Path, event: str, limit: int = 5, project: str | None = None) -> int:
+def run_agent_hook(
+    target: Path, event: str, limit: int = 5, project: str | None = None, emit: str = "text"
+) -> int:
     """Run an installed agent session hook; never fail the agent session."""
     target = target.expanduser().resolve()
     hook_event = _read_hook_stdin()
     try:
         if event == "session-start":
-            return _hook_session_start(target, hook_event, limit, project)
+            return _hook_session_start(target, hook_event, limit, project, emit)
         if event == "session-end":
             return _hook_session_end(target, hook_event, limit, project)
         print(f"Unknown hook event: {event}", file=sys.stderr)
@@ -2782,6 +2890,7 @@ def main(argv: list[str] | None = None) -> int:
             "brief": brief,
             "start": start,
             "hook": run_agent_hook,
+            "consolidate": consolidate,
             "profile": profile,
             "wins": memory_wins,
             "memory-audit": memory_audit,
diff --git a/mcp_package/link_core/agent_hooks.py b/mcp_package/link_core/agent_hooks.py
index df1b0289..62778012 100644
--- a/mcp_package/link_core/agent_hooks.py
+++ b/mcp_package/link_core/agent_hooks.py
@@ -3,6 +3,16 @@
 Hooks let supported agents run the Link memory loop automatically:
 a session-start hook injects a bounded memory brief into new sessions,
 and a session-end hook stores proposal-only session notes for review.
+
+Supported agents differ in mechanism, so each config records its schema:
+- Claude Code: nested hook groups inside `~/.claude/settings.json`;
+  session-start stdout becomes model context; SessionEnd gets a transcript.
+- Codex: the same nested hook schema in `~/.codex/hooks.json`; stdout becomes
+  model context; there is no session-end event (Stop fires per turn, which
+  would be too noisy for capture), so only session-start is installed.
+- Cursor: a flat `~/.cursor/hooks.json` with `version: 1`; session-start must
+  print a JSON envelope with `additional_context`; sessionEnd is fire-and-forget
+  and only captures when Cursor provides a readable transcript path.
 """
 from __future__ import annotations
 
@@ -26,10 +36,12 @@ class AgentHookConfig:
     display_name: str
     aliases: tuple[str, ...]
     default_settings: str
+    schema: str = "nested"  # "nested" (Claude Code, Codex) or "flat" (Cursor)
     start_event: str = "SessionStart"
-    end_event: str = "SessionEnd"
+    end_event: str | None = "SessionEnd"
     # Skip "resume": the resumed context already carries the earlier brief.
-    start_matcher: str = "startup|clear|compact"
+    start_matcher: str | None = "startup|clear|compact"
+    start_emit: str = "text"  # "text" stdout-to-context, or "cursor" JSON envelope
     restart_hint: str = "Restart the agent; new sessions will start with the Link memory brief."
 
 
@@ -40,6 +52,28 @@ class AgentHookConfig:
         aliases=("claude-code", "claude", "claude-code-cli"),
         default_settings="~/.claude/settings.json",
     ),
+    AgentHookConfig(
+        name="codex",
+        display_name="Codex",
+        aliases=("codex",),
+        default_settings="~/.codex/hooks.json",
+        end_event=None,
+        restart_hint=(
+            "Restart Codex and approve the hook when Codex asks you to trust it; "
+            "new sessions will then start with the Link memory brief."
+        ),
+    ),
+    AgentHookConfig(
+        name="cursor",
+        display_name="Cursor",
+        aliases=("cursor",),
+        default_settings="~/.cursor/hooks.json",
+        schema="flat",
+        start_event="sessionStart",
+        end_event="sessionEnd",
+        start_matcher=None,
+        start_emit="cursor",
+    ),
 )
 
 
@@ -75,21 +109,34 @@ def _settings_path(default_settings: str, override: str | None) -> Path:
     return path
 
 
-def _hook_command(python_cmd: str, runtime_script: Path, event: str, target: Path) -> str:
-    return display_command([python_cmd, str(runtime_script), "hook", event, str(target)])
+def _hook_command(
+    python_cmd: str,
+    runtime_script: Path,
+    event: str,
+    target: Path,
+    emit: str = "text",
+) -> str:
+    parts = [python_cmd, str(runtime_script), "hook", event, str(target)]
+    if emit != "text":
+        parts.extend(["--emit", emit])
+    return display_command(parts)
 
 
-def _hook_entry(command: str, timeout: int) -> dict[str, object]:
+def _nested_entry(command: str, timeout: int) -> dict[str, object]:
     return {"type": "command", "command": command, "timeout": timeout}
 
 
+def _flat_entry(command: str, timeout: int) -> dict[str, object]:
+    return {"command": command, "timeout": timeout}
+
+
 def _is_link_hook_command(command: object, event: str) -> bool:
     if not isinstance(command, str):
         return False
     return _HOOK_SCRIPT_MARKER in command and f" hook {event}" in command
 
 
-def _merge_hook_event(
+def _merge_nested_event(
     settings: dict[str, Any],
     event_name: str,
     event: str,
@@ -122,31 +169,93 @@ def _merge_hook_event(
     hooks[event_name] = groups
 
 
-def _hooks_snippet(config: AgentHookConfig, start_entry: dict[str, object], end_entry: dict[str, object]) -> str:
-    return json.dumps(
-        {
-            "hooks": {
-                config.start_event: [{"matcher": config.start_matcher, "hooks": [start_entry]}],
-                config.end_event: [{"hooks": [end_entry]}],
-            }
-        },
-        indent=2,
-    )
-
-
-def _write_hooks(
-    path: Path,
-    config: AgentHookConfig,
-    start_entry: dict[str, object],
-    end_entry: dict[str, object],
+def _merge_flat_event(
+    settings: dict[str, Any],
+    event_name: str,
+    event: str,
+    entry: dict[str, object],
 ) -> None:
+    settings.setdefault("version", 1)
+    hooks = settings.get("hooks")
+    if not isinstance(hooks, dict):
+        hooks = {}
+        settings["hooks"] = hooks
+    entries = hooks.get(event_name)
+    if not isinstance(entries, list):
+        entries = []
+    replaced = False
+    for index, existing in enumerate(entries):
+        if isinstance(existing, dict) and _is_link_hook_command(existing.get("command"), event):
+            entries[index] = dict(entry)
+            replaced = True
+    if not replaced:
+        entries.append(dict(entry))
+    hooks[event_name] = entries
+
+
+def _event_plan(config: AgentHookConfig, python_cmd: str, runtime_script: Path, target: Path) -> list[dict[str, object]]:
+    """Return the ordered event entries this agent should install."""
+    make_entry = _nested_entry if config.schema == "nested" else _flat_entry
+    plan: list[dict[str, object]] = [
+        {
+            "event_name": config.start_event,
+            "event": "session-start",
+            "matcher": config.start_matcher,
+            "entry": make_entry(
+                _hook_command(python_cmd, runtime_script, "session-start", target, emit=config.start_emit),
+                SESSION_START_TIMEOUT_SECONDS,
+            ),
+        }
+    ]
+    if config.end_event:
+        plan.append({
+            "event_name": config.end_event,
+            "event": "session-end",
+            "matcher": None,
+            "entry": make_entry(
+                _hook_command(python_cmd, runtime_script, "session-end", target),
+                SESSION_END_TIMEOUT_SECONDS,
+            ),
+        })
+    return plan
+
+
+def _hooks_snippet(config: AgentHookConfig, plan: list[dict[str, object]]) -> str:
+    hooks: dict[str, object] = {}
+    for item in plan:
+        entry = item["entry"]
+        if config.schema == "nested":
+            group: dict[str, object] = {"hooks": [entry]}
+            if item["matcher"]:
+                group["matcher"] = item["matcher"]
+            hooks[str(item["event_name"])] = [group]
+        else:
+            hooks[str(item["event_name"])] = [entry]
+    payload: dict[str, object] = {"hooks": hooks}
+    if config.schema == "flat":
+        payload = {"version": 1, "hooks": hooks}
+    return json.dumps(payload, indent=2)
+
+
+def _write_hooks(path: Path, config: AgentHookConfig, plan: list[dict[str, object]]) -> None:
     settings: dict[str, Any] = {}
     if path.exists() and path.read_text(encoding="utf-8", errors="replace").strip():
         settings = json.loads(path.read_text(encoding="utf-8", errors="replace"))
         if not isinstance(settings, dict):
             raise ValueError(f"{path} must contain a JSON object")
-    _merge_hook_event(settings, config.start_event, "session-start", start_entry, matcher=config.start_matcher)
-    _merge_hook_event(settings, config.end_event, "session-end", end_entry)
+    for item in plan:
+        entry = item["entry"]
+        assert isinstance(entry, dict)
+        if config.schema == "nested":
+            _merge_nested_event(
+                settings,
+                str(item["event_name"]),
+                str(item["event"]),
+                entry,
+                matcher=item["matcher"] if isinstance(item["matcher"], str) else None,
+            )
+        else:
+            _merge_flat_event(settings, str(item["event_name"]), str(item["event"]), entry)
     atomic_write_json(path, settings)
 
 
@@ -162,33 +271,41 @@ def build_agent_hooks_payload(
     """Build or write session-hook configuration for a supported local agent."""
     config = _hook_agent_by_name(agent)
     path = _settings_path(config.default_settings, settings_path)
-    start_command = _hook_command(python_cmd, runtime_script, "session-start", target)
-    end_command = _hook_command(python_cmd, runtime_script, "session-end", target)
-    start_entry = _hook_entry(start_command, SESSION_START_TIMEOUT_SECONDS)
-    end_entry = _hook_entry(end_command, SESSION_END_TIMEOUT_SECONDS)
+    plan = _event_plan(config, python_cmd, runtime_script, target)
     write_status: dict[str, object] = {"requested": write, "ok": False, "message": "preview only"}
     if write:
         try:
-            _write_hooks(path, config, start_entry, end_entry)
+            _write_hooks(path, config, plan)
             write_status = {"requested": True, "ok": True, "message": f"updated {path}"}
         except Exception as exc:
             write_status = {"requested": True, "ok": False, "message": str(exc)}
 
+    entry_commands = {
+        str(item["event_name"]): str(item["entry"]["command"])  # type: ignore[index]
+        for item in plan
+    }
+    behavior = [
+        f"{config.start_event}: injects a bounded Link memory brief into new agent sessions.",
+    ]
+    if config.end_event:
+        behavior.append(
+            f"{config.end_event}: stores proposal-only session notes locally; durable memory still requires review."
+        )
+    else:
+        behavior.append(
+            f"{config.display_name} has no session-end hook event; end sessions with `lnk session-end` "
+            "or the MCP session_end action to capture memory proposals."
+        )
+
     return {
         "agent": config.name,
         "display_name": config.display_name,
         "target": str(target),
         "settings_path": str(path),
-        "events": {
-            config.start_event: start_command,
-            config.end_event: end_command,
-        },
-        "snippet": _hooks_snippet(config, start_entry, end_entry),
+        "events": entry_commands,
+        "snippet": _hooks_snippet(config, plan),
         "write": write_status,
-        "behavior": [
-            f"{config.start_event}: injects a bounded Link memory brief into new agent sessions.",
-            f"{config.end_event}: stores proposal-only session notes locally; durable memory still requires review.",
-        ],
+        "behavior": behavior,
         "restart_hint": config.restart_hint,
     }
 
diff --git a/mcp_package/link_core/cli_parser.py b/mcp_package/link_core/cli_parser.py
index e5eb3a8d..066db689 100644
--- a/mcp_package/link_core/cli_parser.py
+++ b/mcp_package/link_core/cli_parser.py
@@ -309,6 +309,18 @@ def build_cli_parser(
     hook_cmd.add_argument("target", nargs="?", default=".")
     hook_cmd.add_argument("--limit", type=int, default=5, help="maximum memories in the session-start brief")
     hook_cmd.add_argument("--project", default=None, help="include user/global memories plus this project's memories")
+    hook_cmd.add_argument(
+        "--emit",
+        choices=["text", "cursor"],
+        default="text",
+        help="session-start output envelope: plain text (Claude Code, Codex) or Cursor additional_context JSON",
+    )
+
+    consolidate_cmd = sub.add_parser("consolidate", help="print a read-only plan for the capture and review backlog")
+    consolidate_cmd.add_argument("target", nargs="?", default=".")
+    consolidate_cmd.add_argument("--limit", type=int, default=50, help="maximum captures and review items to include")
+    consolidate_cmd.add_argument("--project", default=None, help="restrict the plan to one project's captures and memories")
+    consolidate_cmd.add_argument("--json", action="store_true", help="print machine-readable consolidation plan")
 
     profile_cmd = sub.add_parser("profile", help="show what Link remembers")
     profile_cmd.add_argument("target", nargs="?", default=".")
@@ -672,7 +684,10 @@ def dispatch_cli_command(args: Any, handlers: Mapping[str, CliHandler]) -> int:
             args.event,
             limit=args.limit,
             project=args.project,
+            emit=args.emit,
         )
+    if command == "consolidate":
+        return handlers["consolidate"](Path(args.target), limit=args.limit, project=args.project, json_output=args.json)
     if command == "profile":
         return handlers["profile"](Path(args.target), limit=args.limit, project=args.project, json_output=args.json)
     if command == "wins":
diff --git a/mcp_package/link_core/cli_runtime.py b/mcp_package/link_core/cli_runtime.py
index 0db55542..0ad28172 100644
--- a/mcp_package/link_core/cli_runtime.py
+++ b/mcp_package/link_core/cli_runtime.py
@@ -525,6 +525,17 @@ def render_session_start_hook_text(payload: Mapping[str, object]) -> tuple[int,
             "No project context or relevant memory yet. To seed source-backed project context "
             f"from this repo's docs, suggest: {display_command(['lnk', 'seed', '.', target])}",
         ])
+    backlog = payload.get("backlog") if isinstance(payload.get("backlog"), Mapping) else {}
+    if backlog.get("backlog"):
+        lines.extend([
+            "",
+            (
+                f"Memory backlog: {backlog.get('pending_captures', 0)} pending captures · "
+                f"{backlog.get('needs_review_memories', 0)} memories need review. "
+                "Offer the user a short consolidation pass this session; "
+                f"{backlog.get('command')} prints a read-only plan with approve/discard commands."
+            ),
+        ])
     lines.extend([
         "",
         "Use this brief before asking the user to repeat durable context. "
diff --git a/mcp_package/link_core/consolidate.py b/mcp_package/link_core/consolidate.py
new file mode 100644
index 00000000..c018a898
--- /dev/null
+++ b/mcp_package/link_core/consolidate.py
@@ -0,0 +1,203 @@
+"""Read-only memory consolidation planning for Link.
+
+Consolidation never writes: it detects backlog (pending raw captures and
+memories that need review), groups duplicate captures, and prints the exact
+review-gated commands to resolve each item with the user. Automatic session
+hooks use the same backlog summary to nudge agents to offer consolidation.
+"""
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .mcp_verify import display_command
+
+BACKLOG_CAPTURE_THRESHOLD = 5
+BACKLOG_REVIEW_THRESHOLD = 8
+
+
+def consolidate_command(command_target: str | Path = ".") -> str:
+    return display_command(["lnk", "consolidate", str(command_target)])
+
+
+def memory_backlog_summary(
+    *,
+    capture_count: int,
+    needs_review_count: int,
+    command_target: str | Path = ".",
+) -> dict[str, object]:
+    """Return the shared backlog signal used by hooks, briefs, and status views."""
+    backlog = capture_count >= BACKLOG_CAPTURE_THRESHOLD or needs_review_count >= BACKLOG_REVIEW_THRESHOLD
+    return {
+        "pending_captures": capture_count,
+        "needs_review_memories": needs_review_count,
+        "backlog": backlog,
+        "capture_threshold": BACKLOG_CAPTURE_THRESHOLD,
+        "review_threshold": BACKLOG_REVIEW_THRESHOLD,
+        "command": consolidate_command(command_target),
+    }
+
+
+def _normalized_snippet(capture: dict[str, object]) -> str:
+    snippet = re.sub(r"\s+", " ", str(capture.get("snippet") or "")).strip().lower()
+    return snippet
+
+
+def _duplicate_capture_groups(captures: list[dict[str, object]]) -> list[dict[str, object]]:
+    """Group captures with identical normalized snippets; newest is kept."""
+    by_snippet: dict[str, list[dict[str, object]]] = {}
+    for capture in captures:
+        snippet = _normalized_snippet(capture)
+        if not snippet:
+            continue
+        by_snippet.setdefault(snippet, []).append(capture)
+    groups: list[dict[str, object]] = []
+    for snippet, members in by_snippet.items():
+        if len(members) < 2:
+            continue
+        # capture_records sorts newest first; keep the newest, mark the rest.
+        keep, *duplicates = members
+        groups.append({
+            "keep": {"path": keep.get("path"), "title": keep.get("title")},
+            "duplicates": [
+                {
+                    "path": item.get("path"),
+                    "title": item.get("title"),
+                    "delete_command": (item.get("commands") or {}).get("delete", "")
+                    if isinstance(item.get("commands"), dict)
+                    else "",
+                }
+                for item in duplicates
+            ],
+        })
+    return groups
+
+
+def build_consolidation_plan(
+    *,
+    captures_payload: dict[str, object],
+    inbox_payload: dict[str, object],
+    command_target: str | Path = ".",
+    project: str | None = None,
+) -> dict[str, object]:
+    """Build a read-only consolidation plan from capture and review backlogs."""
+    captures = captures_payload.get("captures") if isinstance(captures_payload.get("captures"), list) else []
+    capture_count = int(captures_payload.get("count") or len(captures))
+    review_items = inbox_payload.get("items") if isinstance(inbox_payload.get("items"), list) else []
+    needs_review_count = int(inbox_payload.get("review_count") or len(review_items))
+    duplicate_groups = _duplicate_capture_groups([c for c in captures if isinstance(c, dict)])
+    duplicate_count = sum(len(group["duplicates"]) for group in duplicate_groups)
+
+    capture_plan = []
+    duplicate_paths = {
+        str(item["path"])
+        for group in duplicate_groups
+        for item in group["duplicates"]
+    }
+    for capture in captures:
+        if not isinstance(capture, dict):
+            continue
+        commands = capture.get("commands") if isinstance(capture.get("commands"), dict) else {}
+        capture_plan.append({
+            "path": capture.get("path"),
+            "title": capture.get("title"),
+            "project": capture.get("project"),
+            "snippet": capture.get("snippet"),
+            "secret_warning_count": capture.get("warning_count", 0),
+            "duplicate": str(capture.get("path")) in duplicate_paths,
+            "accept_command": commands.get("accept", ""),
+            "delete_command": commands.get("delete", ""),
+        })
+
+    review_plan = []
+    for item in review_items[:10]:
+        if not isinstance(item, dict):
+            continue
+        primary = item.get("primary_action") if isinstance(item.get("primary_action"), dict) else {}
+        review_plan.append({
+            "title": item.get("title"),
+            "severity": item.get("highest_severity"),
+            "command": primary.get("command_text") or primary.get("command") or "",
+        })
+
+    backlog = memory_backlog_summary(
+        capture_count=capture_count,
+        needs_review_count=needs_review_count,
+        command_target=command_target,
+    )
+    return {
+        "project": project or "",
+        "backlog": backlog,
+        "pending_captures": capture_count,
+        "needs_review_memories": needs_review_count,
+        "duplicate_groups": duplicate_groups,
+        "duplicate_capture_count": duplicate_count,
+        "captures": capture_plan,
+        "review_queue": review_plan,
+        "safety": (
+            "Read-only plan. Nothing was merged, deleted, or saved. "
+            "Run the listed commands only after the user approves each action."
+        ),
+    }
+
+
+def render_consolidate_text(payload: dict[str, object]) -> tuple[int, str]:
+    """Render the consolidation plan for terminal and agent use."""
+    backlog = payload.get("backlog") if isinstance(payload.get("backlog"), dict) else {}
+    lines = [
+        "Link consolidation plan (read-only)",
+        "",
+        (
+            f"Pending captures: {payload.get('pending_captures', 0)} · "
+            f"Memories needing review: {payload.get('needs_review_memories', 0)}"
+        ),
+    ]
+    if backlog.get("backlog"):
+        lines.append("Backlog is above threshold; a review session with the user is recommended.")
+    else:
+        lines.append("Backlog is small; consolidation is optional right now.")
+
+    duplicate_groups = payload.get("duplicate_groups") if isinstance(payload.get("duplicate_groups"), list) else []
+    if duplicate_groups:
+        lines.extend(["", f"Duplicate captures ({payload.get('duplicate_capture_count', 0)} safe to delete after review):"])
+        for group in duplicate_groups:
+            if not isinstance(group, dict):
+                continue
+            keep = group.get("keep") if isinstance(group.get("keep"), dict) else {}
+            lines.append(f"- Keep: {keep.get('path')}")
+            for item in group.get("duplicates", []):
+                if isinstance(item, dict):
+                    lines.append(f"  Duplicate: {item.get('path')}")
+                    if item.get("delete_command"):
+                        lines.append(f"    {item.get('delete_command')}")
+
+    captures = payload.get("captures") if isinstance(payload.get("captures"), list) else []
+    unique_captures = [c for c in captures if isinstance(c, dict) and not c.get("duplicate")]
+    if unique_captures:
+        lines.extend(["", "Captures to review with the user:"])
+        for capture in unique_captures[:10]:
+            title = str(capture.get("title") or capture.get("path"))
+            lines.append(f"- {title} ({capture.get('path')})")
+            snippet = str(capture.get("snippet") or "").strip()
+            if snippet:
+                lines.append(f"  {snippet[:140]}")
+            if capture.get("accept_command"):
+                lines.append(f"  Accept: {capture.get('accept_command')}")
+            if capture.get("delete_command"):
+                lines.append(f"  Discard: {capture.get('delete_command')}")
+
+    review_queue = payload.get("review_queue") if isinstance(payload.get("review_queue"), list) else []
+    if review_queue:
+        lines.extend(["", "Memories needing review:"])
+        for item in review_queue:
+            if not isinstance(item, dict):
+                continue
+            lines.append(f"- [{item.get('severity', '?')}] {item.get('title')}")
+            if item.get("command"):
+                lines.append(f"  {item.get('command')}")
+
+    if not duplicate_groups and not unique_captures and not review_queue:
+        lines.extend(["", "Nothing to consolidate. Memory state is clean."])
+
+    lines.extend(["", str(payload.get("safety") or "")])
+    return 0, "\n".join(line for line in lines if line is not None)
diff --git a/mcp_package/link_mcp/server.py b/mcp_package/link_mcp/server.py
index 3231053f..d4f03020 100644
--- a/mcp_package/link_mcp/server.py
+++ b/mcp_package/link_mcp/server.py
@@ -205,6 +205,9 @@ def _slim_tool():
     redact_capture_file as _core_redact_capture_file,
     write_session_capture as _core_write_session_capture,
 )
+from link_core.consolidate import (
+    build_consolidation_plan as _core_build_consolidation_plan,
+)
 from link_core.files import (
     atomic_write_json as _core_atomic_write_json,
 )
@@ -1218,8 +1221,10 @@ def review(
     """Review, explain, and manage local memory lifecycle.
 
     Supported actions: inbox, audit, profile, log, wins, explain, reviewed,
-    archive, restore, forget. Prefer archive over forget unless the user asks
-    for permanent deletion.
+    archive, restore, forget, consolidate. Prefer archive over forget unless
+    the user asks for permanent deletion. Use consolidate for a read-only plan
+    when the capture or review backlog builds up; apply its actions only after
+    the user approves each one.
     """
     clean_action = (_clean_text_input(action, max_len=80) or "inbox").lower().replace("-", "_")
     parsed_limit = _parse_limit(limit, default=20, max_limit=50)
@@ -1245,12 +1250,19 @@ def review(
             payload = _set_memory_status(identifier, "active")
         elif clean_action == "forget":
             payload = _forget_memory(identifier, confirm=confirm)
+        elif clean_action == "consolidate":
+            payload = _core_build_consolidation_plan(
+                captures_payload=_capture_inbox(limit=parsed_limit, project=clean_project),
+                inbox_payload=_memory_inbox(limit=parsed_limit, project=clean_project),
+                command_target=WIKI_DIR.parent,
+                project=clean_project,
+            )
         else:
             return json.dumps({
                 "surface": "slim",
                 "tool": "review",
                 "error": f"unsupported action: {clean_action}",
-                "supported_actions": ["inbox", "audit", "profile", "log", "wins", "explain", "reviewed", "archive", "restore", "forget"],
+                "supported_actions": ["inbox", "audit", "profile", "log", "wins", "explain", "reviewed", "archive", "restore", "forget", "consolidate"],
             })
     except ValueError as exc:
         return json.dumps({"surface": "slim", "tool": "review", "updated": False, "error": str(exc)})
diff --git a/scripts/check_tool_contract.py b/scripts/check_tool_contract.py
index 27744d81..80885366 100644
--- a/scripts/check_tool_contract.py
+++ b/scripts/check_tool_contract.py
@@ -17,6 +17,7 @@
     "capture-inbox",
     "capture-session",
     "connect",
+    "consolidate",
     "compliance-export",
     "delete-capture",
     "demo",
diff --git a/tests/test_agent_hooks_core.py b/tests/test_agent_hooks_core.py
index 4081994a..59825230 100644
--- a/tests/test_agent_hooks_core.py
+++ b/tests/test_agent_hooks_core.py
@@ -21,24 +21,94 @@ def _transcript_line(role: str, content: object) -> str:
 
 
 class AgentHooksCoreTests(unittest.TestCase):
-    def test_hook_supported_agents_include_claude_code(self):
-        self.assertIn("claude-code", hook_supported_agents())
+    def test_hook_supported_agents_include_hook_capable_agents(self):
+        agents = hook_supported_agents()
+        for agent in ("claude-code", "codex", "cursor"):
+            self.assertIn(agent, agents)
 
     def test_supports_agent_hooks_accepts_aliases_and_rejects_others(self):
         self.assertTrue(supports_agent_hooks("claude-code"))
         self.assertTrue(supports_agent_hooks("claude"))
-        self.assertFalse(supports_agent_hooks("codex"))
-        self.assertFalse(supports_agent_hooks("cursor"))
+        self.assertTrue(supports_agent_hooks("codex"))
+        self.assertTrue(supports_agent_hooks("cursor"))
+        self.assertFalse(supports_agent_hooks("kiro"))
+        self.assertFalse(supports_agent_hooks("vscode"))
 
     def test_build_payload_rejects_unsupported_agent(self):
         with self.assertRaises(ValueError):
             build_agent_hooks_payload(
                 target=Path("/tmp/link"),
-                agent="codex",
+                agent="kiro",
                 runtime_script=Path("/tmp/link/link.py"),
                 python_cmd="python3",
             )
 
+    def test_codex_gets_session_start_only(self):
+        payload = build_agent_hooks_payload(
+            target=Path("/tmp/link"),
+            agent="codex",
+            runtime_script=Path("/tmp/link/link.py"),
+            python_cmd="python3",
+        )
+
+        self.assertIn("SessionStart", payload["events"])
+        self.assertNotIn("SessionEnd", payload["events"])
+        self.assertIn("hooks.json", str(payload["settings_path"]))
+        self.assertIn(".codex", str(payload["settings_path"]))
+        snippet = json.loads(str(payload["snippet"]))
+        self.assertEqual(list(snippet["hooks"].keys()), ["SessionStart"])
+        self.assertTrue(any("no session-end hook event" in item for item in payload["behavior"]))
+
+    def test_cursor_uses_flat_schema_and_cursor_emit(self):
+        payload = build_agent_hooks_payload(
+            target=Path("/tmp/link"),
+            agent="cursor",
+            runtime_script=Path("/tmp/link/link.py"),
+            python_cmd="python3",
+        )
+
+        self.assertIn("--emit cursor", str(payload["events"]["sessionStart"]))
+        self.assertNotIn("--emit", str(payload["events"]["sessionEnd"]))
+        snippet = json.loads(str(payload["snippet"]))
+        self.assertEqual(snippet["version"], 1)
+        # Flat schema: entries directly in the event array, no matcher groups.
+        self.assertIn("command", snippet["hooks"]["sessionStart"][0])
+        self.assertNotIn("hooks", snippet["hooks"]["sessionStart"][0])
+
+    def test_cursor_write_preserves_version_and_foreign_entries(self):
+        with tempfile.TemporaryDirectory() as temp:
+            settings = Path(temp) / "hooks.json"
+            settings.write_text(
+                json.dumps({
+                    "version": 1,
+                    "hooks": {
+                        "sessionStart": [{"command": "./my-hook.sh"}],
+                        "stop": [{"command": "./on-stop.sh"}],
+                    },
+                }),
+                encoding="utf-8",
+            )
+
+            for _ in range(2):
+                payload = build_agent_hooks_payload(
+                    target=Path(temp),
+                    agent="cursor",
+                    runtime_script=Path(temp) / "link.py",
+                    python_cmd="python3",
+                    settings_path=str(settings),
+                    write=True,
+                )
+                self.assertTrue(payload["write"]["ok"], payload["write"])
+
+            data = json.loads(settings.read_text(encoding="utf-8"))
+            self.assertEqual(data["version"], 1)
+            self.assertEqual(data["hooks"]["stop"], [{"command": "./on-stop.sh"}])
+            starts = data["hooks"]["sessionStart"]
+            self.assertEqual(starts[0], {"command": "./my-hook.sh"})
+            link_entries = [e for e in starts if "hook session-start" in e.get("command", "")]
+            self.assertEqual(len(link_entries), 1)
+            self.assertEqual(len(data["hooks"]["sessionEnd"]), 1)
+
     def test_build_preview_includes_both_events_and_commands(self):
         payload = build_agent_hooks_payload(
             target=Path("/tmp/my link"),
diff --git a/tests/test_link_cli.py b/tests/test_link_cli.py
index 79deec60..4695432a 100644
--- a/tests/test_link_cli.py
+++ b/tests/test_link_cli.py
@@ -2818,7 +2818,7 @@ def test_hook_session_end_captures_proposal_only_notes(self):
                     "type": "user",
                     "message": {
                         "role": "user",
-                        "content": f"Decision {index}: we keep agent memory in reviewable local Markdown pages.",
+                        "content": f"We decided {index}: deploy the staging site only from the tagged release branch.",
                     },
                 })
                 for index in range(6)
@@ -2836,6 +2836,113 @@ def test_hook_session_end_captures_proposal_only_notes(self):
         self.assertEqual(len(captures), 1)
         self.assertIn("proposal-only", out.getvalue())
 
+    def test_hook_session_start_cursor_emit_wraps_additional_context(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+
+        out = StringIO()
+        with patch("sys.stdin", self._hook_stdin({"workspace_roots": [str(tmp)]})):
+            with redirect_stdout(out):
+                code = link_cli.run_agent_hook(target, "session-start", emit="cursor")
+
+        self.assertEqual(code, 0)
+        payload = json.loads(out.getvalue())
+        self.assertIn("Link memory (local, source-backed)", payload["additional_context"])
+
+    def test_hook_session_end_skips_duplicate_transcript_content(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+        transcript = tmp / "transcript.jsonl"
+        transcript.write_text(
+            "\n".join(
+                json.dumps({
+                    "type": "user",
+                    "message": {
+                        "role": "user",
+                        "content": f"We decided {index}: deploy the staging site only from the tagged release branch.",
+                    },
+                })
+                for index in range(6)
+            ),
+            encoding="utf-8",
+        )
+
+        for _ in range(2):
+            out = StringIO()
+            with patch("sys.stdin", self._hook_stdin({"transcript_path": str(transcript)})):
+                with redirect_stdout(out):
+                    code = link_cli.run_agent_hook(target, "session-end")
+            self.assertEqual(code, 0)
+
+        captures = list((target / "raw/memory-captures").glob("*agent-session-notes*.md"))
+        self.assertEqual(len(captures), 1)
+
+    def test_hook_session_end_skips_sessions_without_memory_proposals(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+        transcript = tmp / "transcript.jsonl"
+        transcript.write_text(
+            "\n".join(
+                json.dumps({
+                    "type": "assistant",
+                    "message": {
+                        "role": "assistant",
+                        "content": [{
+                            "type": "text",
+                            "text": f"I looked at file number {index} and it seems fine to me over there.",
+                        }],
+                    },
+                })
+                for index in range(8)
+            ),
+            encoding="utf-8",
+        )
+
+        out = StringIO()
+        with patch("sys.stdin", self._hook_stdin({"transcript_path": str(transcript)})):
+            with redirect_stdout(out):
+                code = link_cli.run_agent_hook(target, "session-end")
+
+        self.assertEqual(code, 0)
+        captures = list((target / "raw/memory-captures").glob("*agent-session-notes*.md"))
+        self.assertEqual(captures, [])
+
+    def test_consolidate_prints_read_only_plan(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+        transcript = tmp / "transcript.jsonl"
+        transcript.write_text(
+            "\n".join(
+                json.dumps({
+                    "type": "user",
+                    "message": {
+                        "role": "user",
+                        "content": f"We decided {index}: deploy the staging site only from the tagged release branch.",
+                    },
+                })
+                for index in range(6)
+            ),
+            encoding="utf-8",
+        )
+        with patch("sys.stdin", self._hook_stdin({"transcript_path": str(transcript)})):
+            with redirect_stdout(StringIO()):
+                link_cli.run_agent_hook(target, "session-end")
+
+        out = StringIO()
+        with redirect_stdout(out):
+            code = link_cli.consolidate(target, json_output=True)
+
+        self.assertEqual(code, 0)
+        payload = json.loads(out.getvalue())
+        self.assertEqual(payload["pending_captures"], 1)
+        self.assertIn("Read-only plan", payload["safety"])
+        self.assertTrue(payload["captures"][0]["accept_command"])
+        self.assertTrue(payload["captures"][0]["delete_command"])
+
     def test_hook_session_end_skips_trivial_sessions(self):
         tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
         target = tmp / "demo"
@@ -2872,10 +2979,10 @@ def test_connect_hooks_rejects_unsupported_agent(self):
 
         err = StringIO()
         with redirect_stderr(err):
-            code = link_cli.connect_mcp(target, "codex", hooks=True)
+            code = link_cli.connect_mcp(target, "kiro", hooks=True)
 
         self.assertEqual(code, 1)
-        self.assertIn("--hooks is not supported for codex", err.getvalue())
+        self.assertIn("--hooks is not supported for kiro", err.getvalue())
 
     def test_connect_hooks_preview_includes_session_hooks_payload(self):
         tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))

From 6e2a23d1c01aebb3efccaec2232c4a07a3e3cb93 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Tue, 7 Jul 2026 23:41:58 -0600
Subject: [PATCH 03/25] Add optional hybrid semantic recall with a local
 embedding model

Lexical recall stays the default and the fallback. With the optional
link-mcp[semantic] extra and a one-time explicit 'lnk semantic --setup',
a small local static-embedding model (model2vec potion-base-8M) retrieves
close paraphrases that token matching misses, across CLI recall, memory
briefs, MCP recall, and smart query packets.

Local-first guarantees preserved: the model loads offline-only so recall
can never trigger a download; embeddings are plain JSON in .link-cache/;
similarity is in-process cosine with no vector database or service;
LINK_SEMANTIC=off disables the layer.

Scoring is standout-based (z-score against the corpus for each query)
because raw cosine thresholds are not comparable across queries with
static models. Semantic-only matches are labeled match=semantic with
capped confidence so agents verify paraphrases before acting on them,
and they never outrank exact lexical hits.

New scripts/eval_recall_quality.py benchmarks lexical vs hybrid with a
regression gate. Real-model results: paraphrase hit@1 0.50 -> 0.62,
hit@3 0.62 -> 0.75; exact-token queries unchanged at 1.00.
---
 CHANGELOG.md                        |   6 +
 README.md                           |  21 ++
 docs/cli.html                       |   2 +
 link.py                             |  62 ++++-
 mcp_package/link_core/cli_parser.py |   8 +
 mcp_package/link_core/memory.py     |  25 +-
 mcp_package/link_core/query.py      |   4 +
 mcp_package/link_core/semantic.py   | 359 ++++++++++++++++++++++++++++
 mcp_package/link_mcp/server.py      |  12 +-
 mcp_package/pyproject.toml          |   3 +
 scripts/check_tool_contract.py      |   1 +
 scripts/eval_recall_quality.py      | 201 ++++++++++++++++
 tests/test_semantic_core.py         | 205 ++++++++++++++++
 13 files changed, 902 insertions(+), 7 deletions(-)
 create mode 100644 mcp_package/link_core/semantic.py
 create mode 100644 scripts/eval_recall_quality.py
 create mode 100644 tests/test_semantic_core.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e83d8dfa..e1a6eb4c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,12 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 - Added `lnk consolidate` and MCP `review(action="consolidate")` for a read-only backlog plan: pending capture counts, memories needing review, duplicate-capture groups, and paste-safe accept/discard/review commands — nothing is merged, deleted, or saved without the user approving each action.
 - Added an automatic backlog nudge to the injected session-start brief: when pending captures or review items cross a threshold, the brief tells the agent to offer the user a short consolidation pass instead of letting the inbox silently grow.
 - Added session-end capture noise controls: sessions with no memory-worthy proposal candidates are skipped entirely, and duplicate end events for the same conversation content are deduplicated with a local fingerprint, so automatic hooks cannot flood the capture inbox.
+- Added optional hybrid semantic recall (`pip install "link-mcp[semantic]"` + `lnk semantic --setup`): a small local static-embedding model retrieves close paraphrases that token matching misses, across CLI recall, memory briefs, MCP recall, and smart query packets. Lexical recall stays the default and the fallback.
+- Kept the local-first guarantee for semantic recall: the model loads offline-only so a query can never trigger a download (only the explicit `--setup` may fetch the model once), embeddings live in plain JSON under `.link-cache/`, similarity is computed in-process with no vector database or service, and `LINK_SEMANTIC=off` disables the layer.
+- Added standout-based semantic scoring: candidates are selected by how much they stand out from the rest of the corpus for the query (not by raw cosine thresholds, which are not comparable across queries for static models), and semantic-only matches never outrank exact lexical hits.
+- Added honest labeling for semantic recall: recalled memories now carry `match` (`lexical`, `semantic`, or `hybrid`) and `semantic_similarity`, and a match with no lexical evidence is capped at moderate confidence so agents verify paraphrase matches before acting on them.
+- Added `lnk semantic` for the layer's status (provider, model, index state, mode) with explicit setup/rebuild actions and next-step guidance.
+- Added `scripts/eval_recall_quality.py`, a recall-quality benchmark comparing lexical-only and hybrid recall on exact-token and paraphrase query sets, with a CI-safe deterministic embedder mode and a regression gate that fails if hybrid ever scores below lexical. Measured with the real local model: paraphrase hit@1 0.50 → 0.62, hit@3 0.62 → 0.75, exact-token queries unchanged at 1.00.
 - Added `lnk hook session-start` to print the bounded session-start memory brief (readiness, relevant memories with confidence, pending review and capture state, and retrieval guidance) for agent hook runtimes; it scopes the brief to the hook's working directory project and never fails the agent session.
 - Added `lnk hook session-end` to turn an agent transcript into review-gated memory: it extracts bounded user/assistant text (skipping tool calls and outputs), skips trivial sessions, and stores proposal-only session notes through the same duplicate/conflict-safe capture path as `lnk session-end`.
 - Added idempotent, non-destructive session-hook writing to `~/.claude/settings.json` that preserves existing user hooks and settings, replaces only Link's own hook entries on rerun, and skips re-injection on session resume.
diff --git a/README.md b/README.md
index cebf0b01..bf9846a6 100644
--- a/README.md
+++ b/README.md
@@ -337,6 +337,27 @@ lnk connect cursor ~/link --hooks --write
 lnk consolidate ~/link                      # read-only backlog plan, apply only with approval
 ```
 
+### Optional: hybrid semantic recall (still fully local)
+
+Lexical recall is always the default and the fallback. Installing the optional
+semantic extra adds a small local static-embedding model so paraphrased
+queries also find memories phrased differently — "how should I structure my
+pull requests" finds a memory about commit style. Recall never touches the
+network: the model loads offline-only after a one-time explicit setup,
+embeddings live in plain JSON under `.link-cache/`, similarity runs in-process
+with no vector database, and semantic-only matches carry capped confidence
+labels so agents verify before trusting them.
+
+```bash
+pip install "link-mcp[semantic]"
+lnk semantic ~/link --setup   # one-time model fetch, with your approval
+lnk semantic ~/link           # status: lexical only vs hybrid
+```
+
+Measured on the bundled recall eval (`scripts/eval_recall_quality.py`):
+exact-token queries stay perfect, paraphrase hit@1 improves from 0.50 to 0.62
+and hit@3 from 0.62 to 0.75 with the local model.
+
 <details>
 <summary>MCP-only install</summary>
 
diff --git a/docs/cli.html b/docs/cli.html
index 3e265d4d..dd7e35b7 100644
--- a/docs/cli.html
+++ b/docs/cli.html
@@ -133,6 +133,7 @@ <h2 id="maintenance">Maintenance</h2>
 lnk verify-mcp ~/link</code></pre>
         <p>Add <code>--hooks</code> (Claude Code, Codex, Cursor) to also install session hooks: every new session then starts with a bounded Link memory brief injected automatically, and session end stores proposal-only notes with memory candidates for later review — no durable memory is written without approval. Codex has no session-end event, so it gets the session-start brief only. Sessions without memory-worthy content are skipped and duplicate end events are deduplicated, so the capture inbox does not fill with noise. The hooks run <code>lnk hook session-start</code> and <code>lnk hook session-end</code>, which you can also invoke directly to inspect what they inject or capture.</p>
         <p>Use <code>lnk consolidate</code> when the capture or review backlog builds up. It is read-only: it counts pending captures and memories needing review, groups duplicate captures, and prints paste-safe accept/discard/review commands to run with the user. When the backlog crosses a threshold, the injected session-start brief nudges the agent to offer a consolidation pass, and MCP agents can request the same plan through <code>review(action="consolidate")</code>.</p>
+        <p>Use <code>lnk semantic</code> to inspect or enable optional hybrid recall. Lexical recall is always the default and the fallback; installing <code>pip install "link-mcp[semantic]"</code> and running <code>lnk semantic --setup</code> once adds a small local static-embedding model so paraphrased queries also find memories phrased differently. Recall itself never touches the network — the model loads offline-only, embeddings live in plain JSON under <code>.link-cache/</code>, and semantic-only matches are labeled with capped confidence so agents verify before trusting them.</p>
         <p>From a source checkout, use the synthetic large-wiki smoke when you want local scale evidence without touching your real wiki. The script prints the exact <code>lnk serve</code> command and graph URL for the generated fixture.</p>
         <pre><code>python3 scripts/smoke_large_wiki.py --pages 10000</code></pre>
 
@@ -173,6 +174,7 @@ <h2 id="all">All Commands</h2>
 lnk brief "task" [--project slug]
 lnk memory-audit [--project slug]
 lnk consolidate [dir] [--project slug] [--limit N]
+lnk semantic [dir] [--setup] [--rebuild]
 lnk recall "query" [--project slug]
 lnk profile [--project slug]
 lnk wins [--project slug]
diff --git a/link.py b/link.py
index 4fa7ea71..780763df 100644
--- a/link.py
+++ b/link.py
@@ -273,6 +273,13 @@
     memory_backlog_summary as _core_memory_backlog_summary,
     render_consolidate_text as _core_render_consolidate_text,
 )
+from link_core.semantic import (
+    build_semantic_status as _core_build_semantic_status,
+    load_embedder as _core_load_semantic_embedder,
+    refresh_memory_index as _core_refresh_semantic_index,
+    render_semantic_status_text as _core_render_semantic_status_text,
+    semantic_memory_scores as _core_semantic_memory_scores,
+)
 from link_core.obsidian import (
     import_obsidian_vault as _core_import_obsidian_vault,
     render_import_obsidian_text as _core_render_import_obsidian_text,
@@ -454,13 +461,15 @@ def _memory_profile(wiki_dir: Path, limit: int = 10, project: str | None = None)
 
 
 def _memory_brief(wiki_dir: Path, query: str = "", limit: int = 6, project: str | None = None) -> dict[str, object]:
+    records = _memory_records(wiki_dir)
     return _core_memory_brief(
-        _memory_records(wiki_dir),
+        records,
         query=query,
         limit=limit,
         review_command="review-memory",
         project=project,
         command_target=wiki_dir.parent,
+        semantic_scores=_core_semantic_memory_scores(wiki_dir.parent, query, records),
     )
 
 
@@ -487,12 +496,14 @@ def _recall_memories(
     include_archived: bool = False,
     project: str | None = None,
 ) -> list[dict[str, object]]:
+    records = _memory_records(wiki_dir)
     return _core_recall_memories(
-        _memory_records(wiki_dir),
+        records,
         query,
         limit=limit,
         include_archived=include_archived,
         project=project,
+        semantic_scores=_core_semantic_memory_scores(wiki_dir.parent, query, records),
     )
 
 
@@ -1976,6 +1987,52 @@ def _read_hook_stdin() -> dict[str, object]:
     return payload if isinstance(payload, dict) else {}
 
 
+def semantic(target: Path, setup: bool = False, rebuild: bool = False, json_output: bool = False) -> int:
+    """Show, set up, or rebuild the optional local semantic recall layer."""
+    target = target.expanduser().resolve()
+    root = _resolve_link_root(target)
+    wiki_dir = _resolve_wiki_dir(target)
+    if not wiki_dir.exists():
+        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
+        return 1
+    records = _memory_records(wiki_dir)
+    action_error = ""
+    action_result = ""
+    if setup or rebuild:
+        if setup and not json_output:
+            _print_text(
+                "Setting up semantic recall: this may download the local embedding model once "
+                "(a small static-embedding model, tens of MB). Recall itself never uses the network."
+            )
+        embedder = _core_load_semantic_embedder(allow_download=setup)
+        if embedder is None:
+            action_error = (
+                "Semantic provider unavailable. Install it first: pip install \"link-mcp[semantic]\""
+                if setup
+                else "Semantic model not available offline. Run: lnk semantic --setup"
+            )
+        else:
+            index = _core_refresh_semantic_index(root, records, embedder=embedder)
+            items = index.get("items") if isinstance(index.get("items"), dict) else {}
+            action_result = f"Indexed {len(items)} memories."
+    payload = _core_build_semantic_status(root, memory_count=len(records), command_target=root)
+    if action_result:
+        payload["action_result"] = action_result
+    if action_error:
+        payload["action_error"] = action_error
+    if json_output:
+        print(json.dumps(payload, indent=2))
+        return 1 if action_error else 0
+    code, text = _core_render_semantic_status_text(payload)
+    if action_result:
+        _print_text(action_result)
+    if action_error:
+        print(action_error, file=sys.stderr)
+        code = 1
+    _print_text(text)
+    return code
+
+
 def _memory_backlog_summary(target: Path, wiki_dir: Path) -> dict[str, object]:
     """Workspace-wide backlog signal (unscoped: consolidation is a workspace chore)."""
     root = _resolve_link_root(target)
@@ -2891,6 +2948,7 @@ def main(argv: list[str] | None = None) -> int:
             "start": start,
             "hook": run_agent_hook,
             "consolidate": consolidate,
+            "semantic": semantic,
             "profile": profile,
             "wins": memory_wins,
             "memory-audit": memory_audit,
diff --git a/mcp_package/link_core/cli_parser.py b/mcp_package/link_core/cli_parser.py
index 066db689..ea2a4f7a 100644
--- a/mcp_package/link_core/cli_parser.py
+++ b/mcp_package/link_core/cli_parser.py
@@ -316,6 +316,12 @@ def build_cli_parser(
         help="session-start output envelope: plain text (Claude Code, Codex) or Cursor additional_context JSON",
     )
 
+    semantic_cmd = sub.add_parser("semantic", help="show or set up optional local semantic recall")
+    semantic_cmd.add_argument("target", nargs="?", default=".")
+    semantic_cmd.add_argument("--setup", action="store_true", help="fetch the local embedding model once and build the index")
+    semantic_cmd.add_argument("--rebuild", action="store_true", help="rebuild the semantic index offline")
+    semantic_cmd.add_argument("--json", action="store_true", help="print machine-readable semantic status")
+
     consolidate_cmd = sub.add_parser("consolidate", help="print a read-only plan for the capture and review backlog")
     consolidate_cmd.add_argument("target", nargs="?", default=".")
     consolidate_cmd.add_argument("--limit", type=int, default=50, help="maximum captures and review items to include")
@@ -688,6 +694,8 @@ def dispatch_cli_command(args: Any, handlers: Mapping[str, CliHandler]) -> int:
         )
     if command == "consolidate":
         return handlers["consolidate"](Path(args.target), limit=args.limit, project=args.project, json_output=args.json)
+    if command == "semantic":
+        return handlers["semantic"](Path(args.target), setup=args.setup, rebuild=args.rebuild, json_output=args.json)
     if command == "profile":
         return handlers["profile"](Path(args.target), limit=args.limit, project=args.project, json_output=args.json)
     if command == "wins":
diff --git a/mcp_package/link_core/memory.py b/mcp_package/link_core/memory.py
index 149f472b..5fc8f040 100644
--- a/mcp_package/link_core/memory.py
+++ b/mcp_package/link_core/memory.py
@@ -8,6 +8,7 @@
 from pathlib import Path
 
 from .files import atomic_write_text
+from .semantic import semantic_confidence_cap, semantic_match_points
 from .frontmatter import (
     csv_values,
     frontmatter_int,
@@ -1804,6 +1805,7 @@ def memory_brief(
     review_command: str = "review-memory",
     project: str | None = None,
     command_target: str | Path = ".",
+    semantic_scores: Mapping[str, float] | None = None,
 ) -> dict[str, object]:
     """Return the compact memory payload an agent should read before work."""
     limit = max(1, min(limit, 20))
@@ -1823,7 +1825,9 @@ def memory_brief(
     )
 
     if q:
-        relevant = recall_memories(record_list, q, limit=limit, project=project_name)
+        relevant = recall_memories(
+            record_list, q, limit=limit, project=project_name, semantic_scores=semantic_scores
+        )
         selection = "query"
     else:
         relevant = []
@@ -2007,6 +2011,7 @@ def recall_memories(
     limit: int = 10,
     include_archived: bool = False,
     project: str | None = None,
+    semantic_scores: Mapping[str, Mapping[str, float]] | None = None,
 ) -> list[dict[str, object]]:
     q = query.strip()
     if not q:
@@ -2019,14 +2024,28 @@ def recall_memories(
             continue
         if not include_archived and not is_active_memory(record):
             continue
-        score = score_memory(record, q)
+        lexical_score = score_memory(record, q)
+        semantic_match = None
+        if semantic_scores:
+            semantic_match = semantic_scores.get(str(record.get("name") or ""))
+        score = lexical_score + semantic_match_points(semantic_match)
         if score >= MEMORY_RECALL_MIN_SCORE:
+            lexical_hit = lexical_score >= MEMORY_RECALL_MIN_SCORE
             rank_score = memory_rank_score(record, score, project=project_name)
             issues = memory_review_issues(record)
             slim = slim_memory(record)
             slim["score"] = score
             slim["rank_score"] = rank_score
-            slim["confidence"] = memory_recall_confidence(record, q)
+            slim["match"] = (
+                "hybrid" if (lexical_hit and semantic_match) else ("semantic" if semantic_match else "lexical")
+            )
+            if semantic_match:
+                slim["semantic_similarity"] = float(semantic_match.get("cosine") or 0.0)
+            # A match with no lexical evidence is honest about its basis: a
+            # close paraphrase is at most moderate confidence, never strong.
+            slim["confidence"] = (
+                memory_recall_confidence(record, q) if lexical_hit else semantic_confidence_cap(semantic_match)
+            )
             slim["recall"] = recall_state(record, issues)
             slim["review_issue_count"] = len(issues)
             slim["highest_review_severity"] = (
diff --git a/mcp_package/link_core/query.py b/mcp_package/link_core/query.py
index 4f43da46..6c896b8a 100644
--- a/mcp_package/link_core/query.py
+++ b/mcp_package/link_core/query.py
@@ -16,6 +16,7 @@
     normalize_project,
     recall_memories,
 )
+from .semantic import semantic_memory_scores
 from .wiki import context_for_topic, search_pages
 
 
@@ -415,11 +416,13 @@ def query_link(
             "context_packet": [],
         }
 
+    semantic_scores = semantic_memory_scores(wiki_dir.parent, q, record_list)
     raw_memories = recall_memories(
         record_list,
         q,
         limit=limits["memories"] + 1,
         project=project_name,
+        semantic_scores=semantic_scores,
     )
     memory_has_more = len(raw_memories) > limits["memories"]
     memories = [_compact_memory(memory) for memory in raw_memories[: limits["memories"]]]
@@ -429,6 +432,7 @@ def query_link(
         limit=limits["memories"],
         review_command=review_command,
         project=project_name,
+        semantic_scores=semantic_scores,
     )
     raw_search_results = search_pages(q, cache, limit=limits["search_results"] + 1)
     search_has_more = len(raw_search_results) > limits["search_results"]
diff --git a/mcp_package/link_core/semantic.py b/mcp_package/link_core/semantic.py
new file mode 100644
index 00000000..b94301dc
--- /dev/null
+++ b/mcp_package/link_core/semantic.py
@@ -0,0 +1,359 @@
+"""Optional local semantic recall for Link.
+
+Lexical recall stays the default and the fallback. When the optional local
+embedding provider is installed (`pip install "link-mcp[semantic]"`) and its
+small static-embedding model has been fetched once through the explicit
+`lnk semantic --setup` command, memory recall additionally retrieves close
+paraphrases ("how do I like my PRs structured" finding a memory phrased
+around "commit style") that token matching misses.
+
+Local-first guarantees preserved:
+- No network at recall time, ever: model loading is forced offline
+  (`HF_HUB_OFFLINE=1`) everywhere except the explicit setup command, so a
+  query can never trigger a download.
+- No services, no vector database: embeddings live in a plain JSON cache
+  under `.link-cache/semantic/`, similarity is brute-force cosine in pure
+  Python — personal wikis have hundreds of memories, not millions.
+- Deterministic degradation: if the provider, model, or cache is missing or
+  broken, every entry point returns empty results and recall behaves exactly
+  as before.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import os
+from collections.abc import Callable, Iterable, Mapping
+from pathlib import Path
+
+from .files import atomic_write_text
+
+DEFAULT_SEMANTIC_MODEL = "minishlab/potion-base-8M"
+SEMANTIC_MODEL_ENV = "LINK_SEMANTIC_MODEL"
+SEMANTIC_DISABLE_ENV = "LINK_SEMANTIC"
+SEMANTIC_INDEX_VERSION = 1
+
+# Absolute cosine values from small static-embedding models are not
+# comparable across queries (a correct match can score 0.25 on one query and
+# 0.55 on another), so candidate selection is *standout-based*: a memory
+# counts as a semantic match when its similarity stands out from the rest of
+# the corpus for this query (z-score), with a small absolute floor to reject
+# noise-on-noise. `strength` in [0, 1] expresses how much it stands out.
+SEMANTIC_NOISE_FLOOR = 0.15
+SEMANTIC_STANDOUT_Z = 1.0
+SEMANTIC_MAX_CANDIDATES = 5
+SEMANTIC_MODERATE_STRENGTH = 0.5
+# Small corpora make standout statistics unstable; fall back to absolute.
+SEMANTIC_MIN_CORPUS_FOR_STANDOUT = 5
+SEMANTIC_MIN_COSINE = 0.35
+
+Embedder = Callable[[list[str]], list[list[float]]]
+
+_MODEL_CACHE: dict[str, object] = {}
+
+
+def semantic_model_name() -> str:
+    return os.environ.get(SEMANTIC_MODEL_ENV, "").strip() or DEFAULT_SEMANTIC_MODEL
+
+
+def semantic_disabled() -> bool:
+    return os.environ.get(SEMANTIC_DISABLE_ENV, "").strip().lower() in {"0", "off", "false", "no"}
+
+
+def provider_installed() -> bool:
+    try:
+        import model2vec  # noqa: F401
+    except Exception:
+        return False
+    return True
+
+
+def _load_model(allow_download: bool = False):
+    """Load the static embedding model; offline unless setup explicitly allows."""
+    model_name = semantic_model_name()
+    cache_key = f"{model_name}:{allow_download}"
+    cached = _MODEL_CACHE.get(model_name)
+    if cached is not None:
+        return cached
+    if not allow_download:
+        # Force offline so recall can never silently reach the network.
+        os.environ["HF_HUB_OFFLINE"] = "1"
+    else:
+        os.environ.pop("HF_HUB_OFFLINE", None)
+    from model2vec import StaticModel
+
+    model = StaticModel.from_pretrained(model_name)
+    _MODEL_CACHE[model_name] = model
+    del cache_key
+    return model
+
+
+def load_embedder(allow_download: bool = False) -> Embedder | None:
+    """Return a batch embedding callable, or None when unavailable."""
+    if semantic_disabled() or not provider_installed():
+        return None
+    try:
+        model = _load_model(allow_download=allow_download)
+    except Exception:
+        return None
+
+    def _embed(texts: list[str]) -> list[list[float]]:
+        vectors = model.encode(texts)
+        return [[float(value) for value in vector] for vector in vectors]
+
+    return _embed
+
+
+def model_available() -> bool:
+    """True when the model is loadable fully offline."""
+    return load_embedder(allow_download=False) is not None
+
+
+def _normalize(vector: list[float]) -> list[float]:
+    norm = math.sqrt(sum(value * value for value in vector))
+    if norm <= 0:
+        return vector
+    return [value / norm for value in vector]
+
+
+def _cosine(a: list[float], b: list[float]) -> float:
+    # Vectors are stored normalized, so cosine is a plain dot product.
+    return sum(x * y for x, y in zip(a, b))
+
+
+def _content_hash(text: str) -> str:
+    return hashlib.sha256(text.encode("utf-8", errors="replace")).hexdigest()[:16]
+
+
+def memory_embedding_text(record: Mapping[str, object]) -> str:
+    """The bounded text that represents one memory in the semantic index."""
+    tags = " ".join(str(tag) for tag in record.get("tags", []) if str(tag).strip())
+    parts = [
+        str(record.get("title") or ""),
+        str(record.get("tldr") or ""),
+        tags,
+        str(record.get("body") or "")[:1000],
+    ]
+    return "\n".join(part for part in parts if part.strip())
+
+
+def semantic_index_path(root: Path) -> Path:
+    return root.expanduser().resolve() / ".link-cache" / "semantic" / "memories.json"
+
+
+def _load_index(path: Path) -> dict[str, object]:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, ValueError):
+        return {}
+    if not isinstance(payload, dict) or payload.get("version") != SEMANTIC_INDEX_VERSION:
+        return {}
+    return payload
+
+
+def _save_index(path: Path, payload: dict[str, object]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    atomic_write_text(path, json.dumps(payload))
+
+
+def refresh_memory_index(
+    root: Path,
+    records: Iterable[Mapping[str, object]],
+    *,
+    embedder: Embedder,
+    model_name: str | None = None,
+) -> dict[str, object]:
+    """Embed new or changed memories; prune deleted ones. Returns the index."""
+    model = model_name or semantic_model_name()
+    path = semantic_index_path(root)
+    index = _load_index(path)
+    items = index.get("items") if isinstance(index.get("items"), dict) else {}
+    if index.get("model") != model:
+        items = {}
+
+    wanted: dict[str, str] = {}
+    texts_by_name: dict[str, str] = {}
+    for record in records:
+        name = str(record.get("name") or "").strip()
+        if not name:
+            continue
+        text = memory_embedding_text(record)
+        if not text.strip():
+            continue
+        wanted[name] = _content_hash(text)
+        texts_by_name[name] = text
+
+    stale = [
+        name for name, digest in wanted.items()
+        if not isinstance(items.get(name), dict) or items[name].get("hash") != digest
+    ]
+    removed = [name for name in list(items) if name not in wanted]
+    if stale:
+        vectors = embedder([texts_by_name[name] for name in stale])
+        for name, vector in zip(stale, vectors):
+            items[name] = {
+                "hash": wanted[name],
+                "vec": [round(value, 5) for value in _normalize(vector)],
+            }
+    for name in removed:
+        items.pop(name, None)
+
+    payload = {"version": SEMANTIC_INDEX_VERSION, "model": model, "items": items}
+    if stale or removed or not path.exists():
+        _save_index(path, payload)
+    return payload
+
+
+def _candidate_strengths(cosines: dict[str, float]) -> dict[str, dict[str, float]]:
+    """Select standout candidates and grade each with a strength in [0, 1]."""
+    if not cosines:
+        return {}
+    values = list(cosines.values())
+    if len(values) < SEMANTIC_MIN_CORPUS_FOR_STANDOUT:
+        # Too few memories for standout statistics: absolute fallback.
+        return {
+            name: {
+                "cosine": round(value, 4),
+                "strength": round(min(1.0, max(0.0, (value - SEMANTIC_MIN_COSINE) / 0.3)), 4),
+            }
+            for name, value in cosines.items()
+            if value >= SEMANTIC_MIN_COSINE
+        }
+    mean = sum(values) / len(values)
+    variance = sum((value - mean) ** 2 for value in values) / len(values)
+    std = math.sqrt(variance) or 1e-6
+    ranked = sorted(cosines.items(), key=lambda item: item[1], reverse=True)
+    candidates: dict[str, dict[str, float]] = {}
+    for name, value in ranked[:SEMANTIC_MAX_CANDIDATES]:
+        if value < SEMANTIC_NOISE_FLOOR:
+            continue
+        z = (value - mean) / std
+        if z < SEMANTIC_STANDOUT_Z:
+            continue
+        strength = min(1.0, max(0.0, (z - SEMANTIC_STANDOUT_Z) / 2.5))
+        if strength <= 0:
+            continue
+        candidates[name] = {"cosine": round(value, 4), "strength": round(strength, 4)}
+    return candidates
+
+
+def semantic_memory_scores(
+    root: Path,
+    query: str,
+    records: Iterable[Mapping[str, object]],
+    *,
+    embedder: Embedder | None = None,
+) -> dict[str, dict[str, float]]:
+    """Return {memory name: {cosine, strength}} for the query, or {}.
+
+    Never raises and never touches the network: any missing provider, model,
+    cache, or unexpected error degrades to lexical-only recall.
+    """
+    q = query.strip()
+    if not q:
+        return {}
+    try:
+        active_embedder = embedder or load_embedder(allow_download=False)
+        if active_embedder is None:
+            return {}
+        index = refresh_memory_index(root, records, embedder=active_embedder)
+        items = index.get("items")
+        if not isinstance(items, dict) or not items:
+            return {}
+        query_vector = _normalize(active_embedder([q])[0])
+        cosines: dict[str, float] = {}
+        for name, entry in items.items():
+            vector = entry.get("vec") if isinstance(entry, dict) else None
+            if not isinstance(vector, list):
+                continue
+            cosines[name] = _cosine(query_vector, vector)
+        return _candidate_strengths(cosines)
+    except Exception:
+        return {}
+
+
+def semantic_match_points(match: Mapping[str, float] | None) -> int:
+    """Map a semantic match's strength onto the lexical match-score scale.
+
+    A barely-standout candidate contributes little; a clear standout can
+    clear the recall floor on its own but never dominates an exact lexical
+    hit (max 10 points vs 20+ for a verbatim title match).
+    """
+    if not match:
+        return 0
+    strength = float(match.get("strength") or 0.0)
+    return max(0, round(strength * 10))
+
+
+def semantic_confidence_cap(match: Mapping[str, float] | None) -> str:
+    """Honest confidence for a match with no lexical evidence."""
+    strength = float(match.get("strength") or 0.0) if match else 0.0
+    return "moderate" if strength >= SEMANTIC_MODERATE_STRENGTH else "weak"
+
+
+def build_semantic_status(
+    root: Path,
+    *,
+    memory_count: int,
+    command_target: str | Path = ".",
+) -> dict[str, object]:
+    """Readiness report for the optional semantic recall layer."""
+    installed = provider_installed()
+    disabled = semantic_disabled()
+    ready = False
+    index_items = 0
+    index = _load_index(semantic_index_path(root))
+    items = index.get("items")
+    if isinstance(items, dict):
+        index_items = len(items)
+    if installed and not disabled:
+        ready = model_available()
+
+    next_actions: list[str] = []
+    if disabled:
+        next_actions.append(f"unset {SEMANTIC_DISABLE_ENV} to re-enable semantic recall")
+    elif not installed:
+        next_actions.append('pip install "link-mcp[semantic]"')
+        next_actions.append(f"lnk semantic {command_target} --setup")
+    elif not ready:
+        next_actions.append(f"lnk semantic {command_target} --setup")
+    elif index_items < memory_count:
+        next_actions.append(f"lnk semantic {command_target} --rebuild")
+
+    return {
+        "enabled": ready,
+        "disabled_by_env": disabled,
+        "provider": "model2vec" if installed else None,
+        "model": semantic_model_name(),
+        "model_available_offline": ready,
+        "index_path": str(semantic_index_path(root)),
+        "indexed_memories": index_items,
+        "memory_count": memory_count,
+        "mode": "hybrid (lexical + semantic)" if ready else "lexical only",
+        "network_policy": (
+            "Recall never downloads anything: the model loads offline-only. "
+            "Only `lnk semantic --setup` may fetch the model, once, with your approval."
+        ),
+        "next_actions": next_actions,
+    }
+
+
+def render_semantic_status_text(payload: Mapping[str, object]) -> tuple[int, str]:
+    lines = [
+        "Link semantic recall",
+        "",
+        f"Mode: {payload.get('mode')}",
+        f"Provider: {payload.get('provider') or 'not installed'}",
+        f"Model: {payload.get('model')}",
+        f"Indexed memories: {payload.get('indexed_memories')} of {payload.get('memory_count')}",
+        f"Index: {payload.get('index_path')}",
+    ]
+    if payload.get("disabled_by_env"):
+        lines.append(f"Disabled via {SEMANTIC_DISABLE_ENV} environment variable.")
+    actions = payload.get("next_actions")
+    if isinstance(actions, list) and actions:
+        lines.extend(["", "Next:"])
+        lines.extend(f"  {action}" for action in actions)
+    lines.extend(["", str(payload.get("network_policy") or "")])
+    return 0, "\n".join(lines)
diff --git a/mcp_package/link_mcp/server.py b/mcp_package/link_mcp/server.py
index d4f03020..1b1a1626 100644
--- a/mcp_package/link_mcp/server.py
+++ b/mcp_package/link_mcp/server.py
@@ -208,6 +208,9 @@ def _slim_tool():
 from link_core.consolidate import (
     build_consolidation_plan as _core_build_consolidation_plan,
 )
+from link_core.semantic import (
+    semantic_memory_scores as _core_semantic_memory_scores,
+)
 from link_core.files import (
     atomic_write_json as _core_atomic_write_json,
 )
@@ -434,10 +437,13 @@ def _memory_profile(limit: int = 10, project: str = "") -> dict[str, object]:
 
 def _memory_brief(query: str = "", limit: int = 6, project: str = "") -> dict[str, object]:
     project_name = _resolve_project(project)
+    clean_query = _clean_text_input(query, max_len=500)
+    records = _memory_records()
     payload = _core_memory_brief(
-        _memory_records(), query=_clean_text_input(query, max_len=500),
+        records, query=clean_query,
         limit=limit, review_command="review_memory", project=project_name,
         command_target=WIKI_DIR.parent,
+        semantic_scores=_core_semantic_memory_scores(WIKI_DIR.parent, clean_query, records),
     )
     return _core_add_capture_review_to_brief(payload, _capture_review_summary(project=project_name))
 
@@ -516,12 +522,14 @@ def _recall_memories(
     project: str = "",
 ) -> list[dict[str, object]]:
     query = _clean_text_input(query)
+    records = _memory_records()
     return _core_recall_memories(
-        _memory_records(),
+        records,
         query,
         limit=limit,
         include_archived=include_archived,
         project=_resolve_project(project),
+        semantic_scores=_core_semantic_memory_scores(WIKI_DIR.parent, query, records),
     )
 
 
diff --git a/mcp_package/pyproject.toml b/mcp_package/pyproject.toml
index 8468ab09..a03f3364 100644
--- a/mcp_package/pyproject.toml
+++ b/mcp_package/pyproject.toml
@@ -24,6 +24,9 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 
+[project.optional-dependencies]
+semantic = ["model2vec>=0.3"]
+
 [project.urls]
 Homepage = "https://github.com/gowtham0992/link"
 Repository = "https://github.com/gowtham0992/link"
diff --git a/scripts/check_tool_contract.py b/scripts/check_tool_contract.py
index 80885366..05b9360b 100644
--- a/scripts/check_tool_contract.py
+++ b/scripts/check_tool_contract.py
@@ -54,6 +54,7 @@
     "restore-memory",
     "review-memory",
     "seed",
+    "semantic",
     "serve",
     "set-memory-visibility",
     "session-end",
diff --git a/scripts/eval_recall_quality.py b/scripts/eval_recall_quality.py
new file mode 100644
index 00000000..8a8c1625
--- /dev/null
+++ b/scripts/eval_recall_quality.py
@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Measure Link memory recall quality: lexical vs hybrid (semantic) recall.
+
+Runs a fixed set of queries against a synthetic personal-memory corpus and
+reports hit@1 / hit@3 for two query groups:
+
+- lexical: queries sharing tokens with the target memory (must stay perfect)
+- paraphrase: queries phrased differently from the memory (where token
+  matching struggles and local embeddings should help)
+
+Modes:
+- --mode off   lexical-only baseline
+- --mode fake  deterministic synonym-axis embedder (CI-safe, no model)
+- --mode real  the actual local model (requires `pip install "link-mcp[semantic]"`
+               and a cached model via `lnk semantic --setup`; pass
+               --allow-download to fetch it here explicitly)
+
+Exit code is non-zero if hybrid recall ever scores below lexical recall on
+the same cases (hybrid must be a strict superset in quality).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "mcp_package"))
+sys.path.insert(0, str(ROOT / "tests"))
+
+from link_core.memory import recall_memories  # noqa: E402
+from link_core.semantic import load_embedder, semantic_memory_scores  # noqa: E402
+from test_semantic_core import fake_embedder  # noqa: E402
+
+
+def _memory(name: str, title: str, tldr: str, body: str, memory_type: str = "preference") -> dict[str, object]:
+    return {
+        "name": name,
+        "title": title,
+        "tldr": tldr,
+        "tags": [],
+        "body": body,
+        "status": "active",
+        "scope": "user",
+        "memory_type": memory_type,
+        "review_status": "reviewed",
+    }
+
+
+MEMORIES = [
+    _memory(
+        "commit-style", "Commit style",
+        "Small commits, PR summary first.",
+        "The user prefers small commits and pull requests structured with a one-paragraph summary first, then bullet points.",
+    ),
+    _memory(
+        "deploy-from-main", "Deploy from main",
+        "Releases ship only from main.",
+        "Releases ship only from the main branch after CI passes; never deploy from feature branches.",
+        "decision",
+    ),
+    _memory(
+        "sqlite-storage", "SQLite for local storage",
+        "Local data lives in SQLite.",
+        "The project stores local data in SQLite with FTS enabled; no external database services.",
+        "decision",
+    ),
+    _memory(
+        "short-answers", "Short answers with sources",
+        "Keep answers short, cite sources.",
+        "The user prefers short, direct answers that cite the wiki pages they came from.",
+    ),
+    _memory(
+        "python-versions", "Supported Python versions",
+        "Support Python 3.10 through 3.14.",
+        "The project supports Python 3.10 through 3.14 and tests all of them in CI.",
+        "fact",
+    ),
+    _memory(
+        "no-cloud-sync", "No cloud sync",
+        "Memory stays on the machine.",
+        "The project decided agent memory stays in local Markdown files with no cloud synchronization.",
+        "decision",
+    ),
+    _memory(
+        "review-before-merge", "Review before merge",
+        "Every change needs a review pass.",
+        "Every pull request needs at least one review pass before merging to the default branch.",
+        "decision",
+    ),
+    _memory(
+        "meeting-notes-obsidian", "Meeting notes live in Obsidian",
+        "Meeting notes are kept in the Obsidian vault.",
+        "The user keeps meeting notes in an Obsidian vault and imports the relevant ones into Link.",
+        "fact",
+    ),
+]
+
+# (query, expected memory name)
+LEXICAL_CASES = [
+    ("commit style", "commit-style"),
+    ("deploy from main", "deploy-from-main"),
+    ("sqlite storage", "sqlite-storage"),
+    ("short answers with sources", "short-answers"),
+    ("supported python versions", "python-versions"),
+    ("cloud sync", "no-cloud-sync"),
+    ("review before merge", "review-before-merge"),
+    ("meeting notes obsidian", "meeting-notes-obsidian"),
+]
+
+PARAPHRASE_CASES = [
+    ("how should I structure my pull requests", "commit-style"),
+    ("which branch do we ship production builds from", "deploy-from-main"),
+    ("what do we use to persist data on disk", "sqlite-storage"),
+    ("how verbose should my replies be", "short-answers"),
+    ("which interpreter releases must keep working", "python-versions"),
+    ("does anything leave this machine", "no-cloud-sync"),
+    ("can I land this change without another set of eyes", "review-before-merge"),
+    ("where are the writeups from our sync calls", "meeting-notes-obsidian"),
+]
+
+
+def run_cases(cases, embedder, root: Path) -> dict[str, float]:
+    hit1 = hit3 = 0
+    for query, expected in cases:
+        scores = (
+            semantic_memory_scores(root, query, MEMORIES, embedder=embedder)
+            if embedder is not None
+            else None
+        )
+        results = recall_memories(MEMORIES, query, limit=3, semantic_scores=scores)
+        names = [str(item["name"]) for item in results]
+        if names[:1] == [expected]:
+            hit1 += 1
+        if expected in names:
+            hit3 += 1
+    total = len(cases)
+    return {"hit@1": hit1 / total, "hit@3": hit3 / total, "cases": total}
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--mode", choices=["off", "fake", "real"], default="fake")
+    parser.add_argument("--allow-download", action="store_true", help="allow the real model to be fetched once")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    embedder = None
+    if args.mode == "fake":
+        embedder = fake_embedder
+    elif args.mode == "real":
+        embedder = load_embedder(allow_download=args.allow_download)
+        if embedder is None:
+            print(
+                "Real model unavailable. Install with: pip install \"link-mcp[semantic]\" "
+                "and cache the model via `lnk semantic --setup` (or pass --allow-download).",
+                file=sys.stderr,
+            )
+            return 2
+
+    with tempfile.TemporaryDirectory() as temp:
+        root = Path(temp)
+        report = {
+            "mode": args.mode,
+            "lexical_baseline": {
+                "lexical_queries": run_cases(LEXICAL_CASES, None, root),
+                "paraphrase_queries": run_cases(PARAPHRASE_CASES, None, root),
+            },
+            "hybrid": {
+                "lexical_queries": run_cases(LEXICAL_CASES, embedder, root),
+                "paraphrase_queries": run_cases(PARAPHRASE_CASES, embedder, root),
+            } if embedder is not None else None,
+        }
+
+    if args.json:
+        print(json.dumps(report, indent=2))
+    else:
+        print(f"Link recall quality eval (mode: {args.mode})")
+        for label, block in (("lexical-only", report["lexical_baseline"]), ("hybrid", report["hybrid"])):
+            if block is None:
+                continue
+            print(f"\n{label}:")
+            for group, stats in block.items():
+                print(
+                    f"  {group:20s} hit@1 {stats['hit@1']:.2f}  hit@3 {stats['hit@3']:.2f}"
+                    f"  ({stats['cases']} cases)"
+                )
+
+    if report["hybrid"] is not None:
+        for group in ("lexical_queries", "paraphrase_queries"):
+            for metric in ("hit@1", "hit@3"):
+                if report["hybrid"][group][metric] < report["lexical_baseline"][group][metric]:
+                    print(f"REGRESSION: hybrid {group} {metric} below lexical baseline", file=sys.stderr)
+                    return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tests/test_semantic_core.py b/tests/test_semantic_core.py
new file mode 100644
index 00000000..ea414049
--- /dev/null
+++ b/tests/test_semantic_core.py
@@ -0,0 +1,205 @@
+import json
+import math
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "mcp_package"))
+
+from link_core.memory import recall_memories  # noqa: E402
+from link_core.semantic import (  # noqa: E402
+    SEMANTIC_MIN_COSINE,
+    build_semantic_status,
+    memory_embedding_text,
+    refresh_memory_index,
+    semantic_confidence_cap,
+    semantic_index_path,
+    semantic_match_points,
+    semantic_memory_scores,
+)
+
+# Tiny deterministic embedder: maps known concepts onto fixed axes so
+# paraphrases ("structure my pull requests" / "commit style") land close
+# together without any model. Stopwords are dropped and unknown tokens get a
+# small hashed component so unrelated texts stay well below the cosine floor,
+# which is how a real embedding model behaves.
+_CONCEPTS = {
+    0: {"commit", "commits", "committing", "pr", "prs", "pull", "requests", "structure", "structured", "style"},
+    1: {"deploy", "deploys", "release", "releases", "ship", "shipping"},
+    2: {"database", "sqlite", "postgres", "storage", "persist", "disk", "data"},
+}
+_FAKE_STOPWORDS = {
+    "the", "a", "an", "and", "or", "of", "to", "in", "on", "for", "from", "with",
+    "how", "what", "which", "where", "do", "does", "we", "my", "our", "i", "should",
+    "can", "must", "are", "is", "be", "this", "that", "it", "user", "prefers",
+}
+_DIM = 16
+
+
+def fake_embedder(texts: list[str]) -> list[list[float]]:
+    vectors: list[list[float]] = []
+    for text in texts:
+        vector = [0.0] * _DIM
+        for token in text.lower().split():
+            token = "".join(ch for ch in token if ch.isalnum())
+            if not token or token in _FAKE_STOPWORDS:
+                continue
+            for axis, concepts in _CONCEPTS.items():
+                if token in concepts:
+                    vector[axis] += 1.0
+                    break
+            else:
+                vector[3 + (hash(token) % (_DIM - 3))] += 0.05
+        vectors.append(vector)
+    return vectors
+
+
+def _memory(name: str, title: str, body: str, **extra) -> dict[str, object]:
+    record = {
+        "name": name,
+        "title": title,
+        "tldr": "",
+        "tags": [],
+        "body": body,
+        "status": "active",
+        "scope": "user",
+        "memory_type": "preference",
+        "review_status": "reviewed",
+    }
+    record.update(extra)
+    return record
+
+
+COMMIT_MEMORY = _memory(
+    "commit-style",
+    "Commit style",
+    "The user prefers small commits and PRs structured with a summary first.",
+)
+DEPLOY_MEMORY = _memory(
+    "deploy-from-main",
+    "Deploy from main",
+    "Releases ship only from the main branch after CI passes.",
+)
+
+
+class SemanticCoreTests(unittest.TestCase):
+    def test_refresh_index_embeds_and_reuses_unchanged(self):
+        calls: list[int] = []
+
+        def counting_embedder(texts: list[str]) -> list[list[float]]:
+            calls.append(len(texts))
+            return fake_embedder(texts)
+
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            records = [COMMIT_MEMORY, DEPLOY_MEMORY]
+            index = refresh_memory_index(root, records, embedder=counting_embedder)
+            self.assertEqual(len(index["items"]), 2)
+            self.assertEqual(sum(calls), 2)
+
+            refresh_memory_index(root, records, embedder=counting_embedder)
+            self.assertEqual(sum(calls), 2)  # unchanged: no re-embedding
+
+            changed = dict(COMMIT_MEMORY)
+            changed["body"] = "The user now prefers a single squash commit per PR."
+            index = refresh_memory_index(root, [changed], embedder=counting_embedder)
+            self.assertEqual(sum(calls), 3)  # one changed record re-embedded
+            self.assertEqual(list(index["items"]), ["commit-style"])  # deploy pruned
+
+    def test_index_file_is_plain_json(self):
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            refresh_memory_index(root, [COMMIT_MEMORY], embedder=fake_embedder)
+            payload = json.loads(semantic_index_path(root).read_text(encoding="utf-8"))
+            self.assertIn("commit-style", payload["items"])
+            vector = payload["items"]["commit-style"]["vec"]
+            self.assertAlmostEqual(math.sqrt(sum(v * v for v in vector)), 1.0, places=3)
+
+    def test_semantic_scores_find_paraphrase(self):
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            scores = semantic_memory_scores(
+                root,
+                "how should I structure my pull requests",
+                [COMMIT_MEMORY, DEPLOY_MEMORY],
+                embedder=fake_embedder,
+            )
+
+        self.assertIn("commit-style", scores)
+        self.assertGreaterEqual(scores["commit-style"]["cosine"], SEMANTIC_MIN_COSINE)
+        self.assertGreater(scores["commit-style"]["strength"], 0.0)
+        self.assertNotIn("deploy-from-main", scores)
+
+    def test_semantic_scores_empty_query_or_failure_degrade_to_empty(self):
+        with tempfile.TemporaryDirectory() as temp:
+            root = Path(temp)
+            self.assertEqual(semantic_memory_scores(root, "", [COMMIT_MEMORY], embedder=fake_embedder), {})
+
+            def broken_embedder(texts: list[str]) -> list[list[float]]:
+                raise RuntimeError("boom")
+
+            self.assertEqual(
+                semantic_memory_scores(root, "commit style", [COMMIT_MEMORY], embedder=broken_embedder),
+                {},
+            )
+
+    def test_recall_rescues_paraphrase_with_capped_confidence(self):
+        # "structure my pull requests" shares no significant lexical token
+        # with the deploy memory and few with commit-style's exact tokens.
+        query = "how should I structure my pull requests"
+        lexical_only = recall_memories([COMMIT_MEMORY, DEPLOY_MEMORY], query)
+        with tempfile.TemporaryDirectory() as temp:
+            scores = semantic_memory_scores(
+                Path(temp), query, [COMMIT_MEMORY, DEPLOY_MEMORY], embedder=fake_embedder
+            )
+        hybrid = recall_memories([COMMIT_MEMORY, DEPLOY_MEMORY], query, semantic_scores=scores)
+
+        hybrid_names = [str(item["name"]) for item in hybrid]
+        self.assertIn("commit-style", hybrid_names)
+        recalled = next(item for item in hybrid if item["name"] == "commit-style")
+        self.assertIn(recalled["match"], {"semantic", "hybrid"})
+        self.assertIn("semantic_similarity", recalled)
+        if recalled["match"] == "semantic":
+            # No lexical evidence: confidence must be capped below strong.
+            self.assertIn(recalled["confidence"], {"weak", "moderate"})
+        # Hybrid recall is a superset of lexical recall here.
+        for item in lexical_only:
+            self.assertIn(item["name"], hybrid_names)
+
+    def test_lexical_match_keeps_lexical_confidence(self):
+        results = recall_memories(
+            [COMMIT_MEMORY],
+            "commit style",
+            semantic_scores={"commit-style": {"cosine": 0.9, "strength": 0.9}},
+        )
+        self.assertEqual(results[0]["match"], "hybrid")
+        self.assertEqual(results[0]["confidence"], "strong")
+
+    def test_match_points_scale(self):
+        self.assertEqual(semantic_match_points(None), 0)
+        self.assertEqual(semantic_match_points({"strength": 0.0}), 0)
+        self.assertGreaterEqual(semantic_match_points({"strength": 0.5}), 4)
+        self.assertLessEqual(semantic_match_points({"strength": 1.0}), 10)
+
+    def test_confidence_cap(self):
+        self.assertEqual(semantic_confidence_cap({"strength": 0.3}), "weak")
+        self.assertEqual(semantic_confidence_cap({"strength": 0.7}), "moderate")
+        self.assertEqual(semantic_confidence_cap(None), "weak")
+
+    def test_status_without_provider_reports_lexical_only(self):
+        with tempfile.TemporaryDirectory() as temp:
+            payload = build_semantic_status(Path(temp), memory_count=3, command_target=temp)
+        self.assertEqual(payload["mode"], "lexical only")
+        self.assertFalse(payload["enabled"])
+        self.assertTrue(any("--setup" in action for action in payload["next_actions"]))
+
+    def test_memory_embedding_text_is_bounded(self):
+        record = _memory("big", "Big memory", "x" * 10000)
+        self.assertLess(len(memory_embedding_text(record)), 1200)
+
+
+if __name__ == "__main__":
+    unittest.main()

From d17ad986ff6e6c9de32275350d4d97f983a1fd93 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Tue, 7 Jul 2026 23:58:02 -0600
Subject: [PATCH 04/25] Add publication-grade recall benchmark with measured
 results

- scripts/recall_dataset.py: deterministic, fully authored benchmark corpus
  (62 memories incl. 20 distractors, 294 authored queries + phrasing
  variants = 1,176 cases). Queries are classified by MEASURED significant
  stemmed-token overlap with their target, so the zero-overlap paraphrase
  group is provable, not asserted.
- scripts/eval_recall_quality.py: hit@1/3/5, MRR@5, per-domain breakdown,
  recall latency, JSON output, small (CI) and full suites, and a hard
  regression gate: hybrid may never score below lexical on any metric.
  CI runs the gate with a deterministic abstaining fake embedder.
- benchmarks/RESULTS.md: methodology, hardware, model-size ablation
  (potion-base-8M vs 32M), honest limitations, and reproduction steps.
  Measured (Apple M4, real model): token-overlap hit@1 0.589 -> 0.703,
  zero-overlap paraphrase hit@3 0.064 -> 0.136 and hit@5 0.082 -> 0.202,
  ~2.8 ms per recall in-process.
- python -m link_mcp --semantic-setup: explicit one-time model fetch and
  index build for MCP-only installs (found during an external-customer
  walkthrough: pip-only users had no lnk CLI to enable semantic recall).
  The serving path still never touches the network.
---
 CHANGELOG.md                   |   4 +-
 README.md                      |  10 +-
 benchmarks/RESULTS.md          | 118 +++++++++++
 docs/cli.html                  |   2 +-
 mcp_package/link_mcp/server.py |  32 +++
 scripts/eval_recall_quality.py | 272 ++++++++++++------------
 scripts/recall_dataset.py      | 376 +++++++++++++++++++++++++++++++++
 tests/test_recall_benchmark.py |  40 ++++
 tests/test_semantic_core.py    |   9 +-
 9 files changed, 722 insertions(+), 141 deletions(-)
 create mode 100644 benchmarks/RESULTS.md
 create mode 100644 scripts/recall_dataset.py
 create mode 100644 tests/test_recall_benchmark.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e1a6eb4c..fcce2cdb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,7 +17,9 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 - Added standout-based semantic scoring: candidates are selected by how much they stand out from the rest of the corpus for the query (not by raw cosine thresholds, which are not comparable across queries for static models), and semantic-only matches never outrank exact lexical hits.
 - Added honest labeling for semantic recall: recalled memories now carry `match` (`lexical`, `semantic`, or `hybrid`) and `semantic_similarity`, and a match with no lexical evidence is capped at moderate confidence so agents verify paraphrase matches before acting on them.
 - Added `lnk semantic` for the layer's status (provider, model, index state, mode) with explicit setup/rebuild actions and next-step guidance.
-- Added `scripts/eval_recall_quality.py`, a recall-quality benchmark comparing lexical-only and hybrid recall on exact-token and paraphrase query sets, with a CI-safe deterministic embedder mode and a regression gate that fails if hybrid ever scores below lexical. Measured with the real local model: paraphrase hit@1 0.50 → 0.62, hit@3 0.62 → 0.75, exact-token queries unchanged at 1.00.
+- Added a publication-grade recall benchmark: `scripts/recall_dataset.py` (62-memory corpus with distractors, 294 authored queries plus deterministic phrasing variants for 1,176 total cases, every query auto-classified by measured token overlap so the paraphrase group provably shares no significant stemmed token with its target) and `scripts/eval_recall_quality.py` (hit@1/3/5, MRR@5, per-domain breakdown, recall latency, JSON output, and a regression gate that fails if hybrid ever scores below lexical). CI runs the gate with a deterministic no-model embedder.
+- Published measured results in `benchmarks/RESULTS.md` with methodology, hardware, model-size ablation, honest limitations, and reproduction steps: hybrid recall lifts token-overlap hit@1 0.589 → 0.703 and doubles-to-triples zero-overlap paraphrase hit@3/hit@5, at ~2.8 ms per recall in-process.
+- Added `python3 -m link_mcp --semantic-setup` so MCP-only installs (no `lnk` CLI) can run the explicit one-time semantic model fetch and index build; the MCP server itself still never touches the network.
 - Added `lnk hook session-start` to print the bounded session-start memory brief (readiness, relevant memories with confidence, pending review and capture state, and retrieval guidance) for agent hook runtimes; it scopes the brief to the hook's working directory project and never fails the agent session.
 - Added `lnk hook session-end` to turn an agent transcript into review-gated memory: it extracts bounded user/assistant text (skipping tool calls and outputs), skips trivial sessions, and stores proposal-only session notes through the same duplicate/conflict-safe capture path as `lnk session-end`.
 - Added idempotent, non-destructive session-hook writing to `~/.claude/settings.json` that preserves existing user hooks and settings, replaces only Link's own hook entries on rerun, and skips re-injection on session resume.
diff --git a/README.md b/README.md
index bf9846a6..85b62578 100644
--- a/README.md
+++ b/README.md
@@ -352,11 +352,15 @@ labels so agents verify before trusting them.
 pip install "link-mcp[semantic]"
 lnk semantic ~/link --setup   # one-time model fetch, with your approval
 lnk semantic ~/link           # status: lexical only vs hybrid
+python3 -m link_mcp --semantic-setup --wiki ~/link/wiki   # MCP-only installs
 ```
 
-Measured on the bundled recall eval (`scripts/eval_recall_quality.py`):
-exact-token queries stay perfect, paraphrase hit@1 improves from 0.50 to 0.62
-and hit@3 from 0.62 to 0.75 with the local model.
+Measured, not asserted: on the bundled 1,176-case benchmark over a
+62-memory corpus, hybrid recall lifts token-overlap hit@1 from 0.589 to
+0.703 and roughly doubles-to-triples pure-paraphrase (zero token overlap)
+hit@3/hit@5, at ~2.8 ms per recall with no service or vector database.
+Full methodology, honest limitations, and reproduction steps:
+[benchmarks/RESULTS.md](benchmarks/RESULTS.md).
 
 <details>
 <summary>MCP-only install</summary>
diff --git a/benchmarks/RESULTS.md b/benchmarks/RESULTS.md
new file mode 100644
index 00000000..5078dd56
--- /dev/null
+++ b/benchmarks/RESULTS.md
@@ -0,0 +1,118 @@
+# Link recall quality benchmark
+
+Link's recall is measured, not asserted. This document holds the current
+numbers, exactly how they were produced, and how to reproduce them on your
+own machine. The benchmark is deterministic and fully local: no LLM calls,
+no network, no randomness — every memory and query is authored text checked
+into this repository.
+
+## What is measured
+
+Given a personal-memory corpus and a query, Link's `recall` ranks memories.
+We measure whether the correct memory appears at rank 1 / top 3 / top 5
+(hit@1, hit@3, hit@5) and the mean reciprocal rank (MRR@5), comparing:
+
+- **lexical-only** — Link's default recall: token matching with stemming,
+  synonym groups, and rank boosts. Zero dependencies.
+- **hybrid** — lexical plus the optional local semantic layer
+  (`pip install "link-mcp[semantic]"`, model2vec `potion-base-8M`,
+  ~30 MB static embeddings, loaded offline-only).
+
+## Dataset
+
+`scripts/recall_dataset.py`:
+
+- **62 memories** across six domains (tooling, process, infra, data,
+  preferences, project facts), including 20 distractor memories with no
+  queries, so ranking competes against realistic noise. This corpus size
+  reflects real personal agent memory (dozens to hundreds of memories, not
+  millions of documents).
+- **1,176 cases** in the full suite: 294 authored queries (7 per intent,
+  mixing natural token-matching phrasings and true paraphrases) plus 882
+  deterministic phrasing variants ("quick question: …", "remind me: …") that
+  test framing robustness. The small suite (294 authored cases) is what CI
+  runs.
+- **Honest grouping**: queries are classified by *measured* overlap, not by
+  authorship. A query counts as `zero-overlap` only if it provably shares no
+  significant stemmed token with any text of its target memory — i.e. pure
+  paraphrases that token matching cannot reach directly.
+
+## Results
+
+Full suite (1,176 cases), model2vec potion-base-8M, Apple M4, macOS 26.5.1,
+Python 3.14. Run date: 2026-07-07, Link `develop` (post-1.5.0).
+
+### Token-overlap queries (800 cases)
+
+| metric | lexical-only | hybrid | change |
+|---|---|---|---|
+| hit@1 | 0.589 | **0.703** | +11.4 pp |
+| hit@3 | 0.729 | **0.833** | +10.4 pp |
+| hit@5 | 0.815 | **0.880** | +6.5 pp |
+| MRR@5 | 0.668 | **0.769** | +0.101 |
+
+Semantic evidence helps even when tokens match: it disambiguates between
+several memories that share words with the query.
+
+### Zero-overlap queries — pure paraphrases (376 cases)
+
+| metric | lexical-only | hybrid | change |
+|---|---|---|---|
+| hit@1 | 0.048 | **0.074** | 1.5× |
+| hit@3 | 0.064 | **0.136** | 2.1× |
+| hit@5 | 0.082 | **0.202** | 2.5× |
+| MRR@5 | 0.058 | **0.115** | 2.0× |
+
+### Latency (per recall over the 62-memory corpus)
+
+| mode | p50 | p95 | mean |
+|---|---|---|---|
+| lexical-only | 1.33 ms | 1.85 ms | 1.32 ms |
+| hybrid | 2.76 ms | 3.31 ms | 2.79 ms |
+
+In-process, no service, no vector database. The one-time model load
+(~100 ms) is excluded; embedding-index refresh is incremental and
+content-hash keyed.
+
+### Model size ablation (authored 294-case suite)
+
+| model | size | zero-overlap hit@3 | hit@5 | hybrid mean latency |
+|---|---|---|---|---|
+| none (lexical) | 0 | 0.064 | 0.074 | 1.15 ms |
+| potion-base-8M (default) | ~30 MB | 0.149 | 0.234 | 2.62 ms |
+| potion-base-32M | ~120 MB | 0.160 | 0.266 | 3.73 ms |
+
+The 32M model buys little over 8M on this task, which is why 8M is the
+default (`LINK_SEMANTIC_MODEL` overrides it).
+
+## Honest limitations
+
+- **Pure paraphrases remain hard.** Hybrid recall doubles-to-triples
+  zero-overlap performance, but the majority of pure paraphrases still miss
+  the top 5 at this corpus size with a 30 MB static model. Link labels
+  every semantic-only match (`match: semantic`, capped confidence) so agents
+  verify before trusting — we consider honest uncertainty a feature, and we
+  publish the miss rate rather than hiding it.
+- **The dataset is authored by the Link project.** It was written before
+  tuning was finalized and the scoring gate fails the build if hybrid ever
+  regresses lexical, but it is not an independent third-party benchmark.
+  Contributions of adversarial cases are welcome — the format is five lines
+  per intent in `scripts/recall_dataset.py`.
+- **Not comparable to hosted-memory benchmark numbers** (e.g. DMR/LoCoMo
+  scores from cloud systems): those measure LLM answer quality with
+  server-side embeddings or knowledge graphs and per-ingestion LLM calls.
+  Link's benchmark measures deterministic local ranking with zero network
+  and zero LLM involvement — a different, stricter privacy contract.
+
+## Reproduce
+
+```bash
+git clone https://github.com/gowtham0992/link && cd link
+python3 -m venv /tmp/linkbench && /tmp/linkbench/bin/pip install model2vec
+/tmp/linkbench/bin/python scripts/eval_recall_quality.py --suite full --mode real --allow-download
+# lexical baseline only (no dependencies):
+python3 scripts/eval_recall_quality.py --suite full --mode off
+```
+
+`--mode fake` runs a deterministic no-model embedder; CI uses it with a
+regression gate: hybrid may never score below lexical on any group metric.
diff --git a/docs/cli.html b/docs/cli.html
index dd7e35b7..bc56ef24 100644
--- a/docs/cli.html
+++ b/docs/cli.html
@@ -133,7 +133,7 @@ <h2 id="maintenance">Maintenance</h2>
 lnk verify-mcp ~/link</code></pre>
         <p>Add <code>--hooks</code> (Claude Code, Codex, Cursor) to also install session hooks: every new session then starts with a bounded Link memory brief injected automatically, and session end stores proposal-only notes with memory candidates for later review — no durable memory is written without approval. Codex has no session-end event, so it gets the session-start brief only. Sessions without memory-worthy content are skipped and duplicate end events are deduplicated, so the capture inbox does not fill with noise. The hooks run <code>lnk hook session-start</code> and <code>lnk hook session-end</code>, which you can also invoke directly to inspect what they inject or capture.</p>
         <p>Use <code>lnk consolidate</code> when the capture or review backlog builds up. It is read-only: it counts pending captures and memories needing review, groups duplicate captures, and prints paste-safe accept/discard/review commands to run with the user. When the backlog crosses a threshold, the injected session-start brief nudges the agent to offer a consolidation pass, and MCP agents can request the same plan through <code>review(action="consolidate")</code>.</p>
-        <p>Use <code>lnk semantic</code> to inspect or enable optional hybrid recall. Lexical recall is always the default and the fallback; installing <code>pip install "link-mcp[semantic]"</code> and running <code>lnk semantic --setup</code> once adds a small local static-embedding model so paraphrased queries also find memories phrased differently. Recall itself never touches the network — the model loads offline-only, embeddings live in plain JSON under <code>.link-cache/</code>, and semantic-only matches are labeled with capped confidence so agents verify before trusting them.</p>
+        <p>Use <code>lnk semantic</code> to inspect or enable optional hybrid recall. Lexical recall is always the default and the fallback; installing <code>pip install "link-mcp[semantic]"</code> and running <code>lnk semantic --setup</code> once (or <code>python3 -m link_mcp --semantic-setup</code> for MCP-only installs) adds a small local static-embedding model so paraphrased queries also find memories phrased differently. Recall itself never touches the network — the model loads offline-only, embeddings live in plain JSON under <code>.link-cache/</code>, and semantic-only matches are labeled with capped confidence so agents verify before trusting them. Measured results and methodology live in <code>benchmarks/RESULTS.md</code>.</p>
         <p>From a source checkout, use the synthetic large-wiki smoke when you want local scale evidence without touching your real wiki. The script prints the exact <code>lnk serve</code> command and graph URL for the generated fixture.</p>
         <pre><code>python3 scripts/smoke_large_wiki.py --pages 10000</code></pre>
 
diff --git a/mcp_package/link_mcp/server.py b/mcp_package/link_mcp/server.py
index 1b1a1626..c947e3fb 100644
--- a/mcp_package/link_mcp/server.py
+++ b/mcp_package/link_mcp/server.py
@@ -39,6 +39,7 @@
 parser.add_argument("--wiki", default=None)
 parser.add_argument("--surface", choices=("full", "slim"), default=None)
 parser.add_argument("--version", action="store_true")
+parser.add_argument("--semantic-setup", action="store_true")
 args, _ = parser.parse_known_args()
 
 if args.version:
@@ -50,6 +51,37 @@
 else:
     WIKI_DIR = Path.home() / "link" / "wiki"
 
+if args.semantic_setup:
+    # One-time explicit opt-in for MCP-only installs (no `lnk` CLI): fetch
+    # the local embedding model and build the semantic index, then exit.
+    # This is the only link-mcp entry point allowed to touch the network.
+    from link_core.memory import memory_records as _setup_memory_records
+    from link_core.semantic import (
+        load_embedder as _setup_load_embedder,
+        refresh_memory_index as _setup_refresh_index,
+        semantic_model_name as _setup_model_name,
+    )
+
+    if not WIKI_DIR.exists():
+        print(f"[link-mcp] Wiki not found at {WIKI_DIR}; pass --wiki /path/to/wiki.", file=sys.stderr)
+        sys.exit(2)
+    print(
+        f"[link-mcp] Setting up semantic recall: this may download {_setup_model_name()} "
+        "once. Recall itself never uses the network."
+    )
+    setup_embedder = _setup_load_embedder(allow_download=True)
+    if setup_embedder is None:
+        print(
+            "[link-mcp] Semantic provider unavailable. Install it first: "
+            "pip install \"link-mcp[semantic]\"",
+            file=sys.stderr,
+        )
+        sys.exit(2)
+    setup_index = _setup_refresh_index(WIKI_DIR.parent, _setup_memory_records(WIKI_DIR), embedder=setup_embedder)
+    setup_items = setup_index.get("items") if isinstance(setup_index.get("items"), dict) else {}
+    print(f"[link-mcp] Semantic recall ready: indexed {len(setup_items)} memories.")
+    sys.exit(0)
+
 MCP_SURFACE = (args.surface or os.environ.get("LINK_MCP_SURFACE") or "slim").strip().lower()
 if MCP_SURFACE not in {"full", "slim"}:
     print(
diff --git a/scripts/eval_recall_quality.py b/scripts/eval_recall_quality.py
index 8a8c1625..9c535274 100644
--- a/scripts/eval_recall_quality.py
+++ b/scripts/eval_recall_quality.py
@@ -1,149 +1,155 @@
 #!/usr/bin/env python3
-"""Measure Link memory recall quality: lexical vs hybrid (semantic) recall.
+"""Benchmark Link memory recall quality: lexical vs hybrid (semantic) recall.
 
-Runs a fixed set of queries against a synthetic personal-memory corpus and
-reports hit@1 / hit@3 for two query groups:
+Dataset: scripts/recall_dataset.py — fully authored, deterministic, auditable
+(no LLM, no network, no randomness). Queries are classified by *measured*
+token overlap with their target memory, not by how they were authored:
 
-- lexical: queries sharing tokens with the target memory (must stay perfect)
-- paraphrase: queries phrased differently from the memory (where token
-  matching struggles and local embeddings should help)
+- token-overlap: the query shares at least one significant stemmed token
+  with its target memory (lexical recall has a fighting chance)
+- zero-overlap: the query provably shares no significant stemmed token with
+  its target (pure paraphrase; token matching cannot find it directly)
+
+Metrics per group and mode: hit@1, hit@3, hit@5, MRR@5, plus recall latency.
 
 Modes:
 - --mode off   lexical-only baseline
 - --mode fake  deterministic synonym-axis embedder (CI-safe, no model)
-- --mode real  the actual local model (requires `pip install "link-mcp[semantic]"`
-               and a cached model via `lnk semantic --setup`; pass
-               --allow-download to fetch it here explicitly)
+- --mode real  the actual local model (pip install "link-mcp[semantic]";
+               pass --allow-download to fetch it here explicitly)
+
+Exit code is non-zero if hybrid recall scores below lexical recall on any
+group metric (hybrid must never regress lexical behavior).
 
-Exit code is non-zero if hybrid recall ever scores below lexical recall on
-the same cases (hybrid must be a strict superset in quality).
+Reproduce the published numbers:
+    python3 -m venv /tmp/linkbench && /tmp/linkbench/bin/pip install model2vec
+    /tmp/linkbench/bin/python scripts/eval_recall_quality.py \
+        --suite full --mode real --allow-download
 """
 from __future__ import annotations
 
 import argparse
 import json
+import statistics
 import sys
 import tempfile
+import time
 from pathlib import Path
 
 ROOT = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(ROOT / "mcp_package"))
 sys.path.insert(0, str(ROOT / "tests"))
-
-from link_core.memory import recall_memories  # noqa: E402
+sys.path.insert(0, str(ROOT / "scripts"))
+
+from link_core.memory import (  # noqa: E402
+    memory_tokens,
+    recall_memories,
+    significant_memory_tokens,
+    stemmed_memory_tokens,
+)
 from link_core.semantic import load_embedder, semantic_memory_scores  # noqa: E402
+from recall_dataset import build_cases, build_corpus  # noqa: E402
 from test_semantic_core import fake_embedder  # noqa: E402
 
+RANK_LIMIT = 5
 
-def _memory(name: str, title: str, tldr: str, body: str, memory_type: str = "preference") -> dict[str, object]:
-    return {
-        "name": name,
-        "title": title,
-        "tldr": tldr,
-        "tags": [],
-        "body": body,
-        "status": "active",
-        "scope": "user",
-        "memory_type": memory_type,
-        "review_status": "reviewed",
-    }
+
+def _target_tokens(memory: dict[str, object]) -> set[str]:
+    text = " ".join([
+        str(memory.get("title") or ""),
+        str(memory.get("tldr") or ""),
+        " ".join(str(tag) for tag in memory.get("tags", [])),
+        str(memory.get("body") or ""),
+    ])
+    return stemmed_memory_tokens(memory_tokens(text))
+
+
+def classify_cases(cases: list[dict[str, str]], corpus: list[dict[str, object]]) -> None:
+    """Annotate each case with its measured overlap group."""
+    tokens_by_name = {str(memory["name"]): _target_tokens(memory) for memory in corpus}
+    for case in cases:
+        query_tokens = stemmed_memory_tokens(significant_memory_tokens(case["query"]))
+        overlap = query_tokens & tokens_by_name[case["target"]]
+        case["group"] = "token-overlap" if overlap else "zero-overlap"
+
+
+def _blank_stats() -> dict[str, float]:
+    return {"hit@1": 0.0, "hit@3": 0.0, "hit@5": 0.0, "mrr@5": 0.0, "cases": 0}
 
 
-MEMORIES = [
-    _memory(
-        "commit-style", "Commit style",
-        "Small commits, PR summary first.",
-        "The user prefers small commits and pull requests structured with a one-paragraph summary first, then bullet points.",
-    ),
-    _memory(
-        "deploy-from-main", "Deploy from main",
-        "Releases ship only from main.",
-        "Releases ship only from the main branch after CI passes; never deploy from feature branches.",
-        "decision",
-    ),
-    _memory(
-        "sqlite-storage", "SQLite for local storage",
-        "Local data lives in SQLite.",
-        "The project stores local data in SQLite with FTS enabled; no external database services.",
-        "decision",
-    ),
-    _memory(
-        "short-answers", "Short answers with sources",
-        "Keep answers short, cite sources.",
-        "The user prefers short, direct answers that cite the wiki pages they came from.",
-    ),
-    _memory(
-        "python-versions", "Supported Python versions",
-        "Support Python 3.10 through 3.14.",
-        "The project supports Python 3.10 through 3.14 and tests all of them in CI.",
-        "fact",
-    ),
-    _memory(
-        "no-cloud-sync", "No cloud sync",
-        "Memory stays on the machine.",
-        "The project decided agent memory stays in local Markdown files with no cloud synchronization.",
-        "decision",
-    ),
-    _memory(
-        "review-before-merge", "Review before merge",
-        "Every change needs a review pass.",
-        "Every pull request needs at least one review pass before merging to the default branch.",
-        "decision",
-    ),
-    _memory(
-        "meeting-notes-obsidian", "Meeting notes live in Obsidian",
-        "Meeting notes are kept in the Obsidian vault.",
-        "The user keeps meeting notes in an Obsidian vault and imports the relevant ones into Link.",
-        "fact",
-    ),
-]
-
-# (query, expected memory name)
-LEXICAL_CASES = [
-    ("commit style", "commit-style"),
-    ("deploy from main", "deploy-from-main"),
-    ("sqlite storage", "sqlite-storage"),
-    ("short answers with sources", "short-answers"),
-    ("supported python versions", "python-versions"),
-    ("cloud sync", "no-cloud-sync"),
-    ("review before merge", "review-before-merge"),
-    ("meeting notes obsidian", "meeting-notes-obsidian"),
-]
-
-PARAPHRASE_CASES = [
-    ("how should I structure my pull requests", "commit-style"),
-    ("which branch do we ship production builds from", "deploy-from-main"),
-    ("what do we use to persist data on disk", "sqlite-storage"),
-    ("how verbose should my replies be", "short-answers"),
-    ("which interpreter releases must keep working", "python-versions"),
-    ("does anything leave this machine", "no-cloud-sync"),
-    ("can I land this change without another set of eyes", "review-before-merge"),
-    ("where are the writeups from our sync calls", "meeting-notes-obsidian"),
-]
-
-
-def run_cases(cases, embedder, root: Path) -> dict[str, float]:
-    hit1 = hit3 = 0
-    for query, expected in cases:
+def run_suite(
+    cases: list[dict[str, str]],
+    corpus: list[dict[str, object]],
+    embedder,
+    root: Path,
+) -> dict[str, object]:
+    groups: dict[str, dict[str, float]] = {}
+    domains: dict[str, dict[str, float]] = {}
+    latencies: list[float] = []
+    for case in cases:
+        started = time.perf_counter()
         scores = (
-            semantic_memory_scores(root, query, MEMORIES, embedder=embedder)
+            semantic_memory_scores(root, case["query"], corpus, embedder=embedder)
             if embedder is not None
             else None
         )
-        results = recall_memories(MEMORIES, query, limit=3, semantic_scores=scores)
+        results = recall_memories(corpus, case["query"], limit=RANK_LIMIT, semantic_scores=scores)
+        latencies.append((time.perf_counter() - started) * 1000)
         names = [str(item["name"]) for item in results]
-        if names[:1] == [expected]:
-            hit1 += 1
-        if expected in names:
-            hit3 += 1
-    total = len(cases)
-    return {"hit@1": hit1 / total, "hit@3": hit3 / total, "cases": total}
+        rank = names.index(case["target"]) + 1 if case["target"] in names else 0
+        for bucket in (groups.setdefault(case["group"], _blank_stats()),
+                       domains.setdefault(case["domain"], _blank_stats())):
+            bucket["cases"] += 1
+            if rank == 1:
+                bucket["hit@1"] += 1
+            if 1 <= rank <= 3:
+                bucket["hit@3"] += 1
+            if 1 <= rank <= 5:
+                bucket["hit@5"] += 1
+            if rank:
+                bucket["mrr@5"] += 1.0 / rank
+    for bucket_map in (groups, domains):
+        for stats in bucket_map.values():
+            count = stats["cases"] or 1
+            for metric in ("hit@1", "hit@3", "hit@5", "mrr@5"):
+                stats[metric] = round(stats[metric] / count, 4)
+    return {
+        "groups": groups,
+        "domains": domains,
+        "latency_ms": {
+            "p50": round(statistics.median(latencies), 2),
+            "p95": round(sorted(latencies)[int(len(latencies) * 0.95) - 1], 2),
+            "mean": round(statistics.fmean(latencies), 2),
+        },
+    }
+
+
+def _print_block(label: str, block: dict[str, object], show_domains: bool) -> None:
+    print(f"\n{label}:")
+    for group in sorted(block["groups"]):
+        stats = block["groups"][group]
+        print(
+            f"  {group:14s} hit@1 {stats['hit@1']:.3f}  hit@3 {stats['hit@3']:.3f}"
+            f"  hit@5 {stats['hit@5']:.3f}  mrr@5 {stats['mrr@5']:.3f}  ({int(stats['cases'])} cases)"
+        )
+    latency = block["latency_ms"]
+    print(f"  latency/query  p50 {latency['p50']}ms  p95 {latency['p95']}ms  mean {latency['mean']}ms")
+    if show_domains:
+        for domain in sorted(block["domains"]):
+            stats = block["domains"][domain]
+            print(
+                f"    {domain:12s} hit@1 {stats['hit@1']:.3f}  hit@3 {stats['hit@3']:.3f}"
+                f"  ({int(stats['cases'])} cases)"
+            )
 
 
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--mode", choices=["off", "fake", "real"], default="fake")
+    parser.add_argument("--suite", choices=["small", "full"], default="small",
+                        help="small: authored queries only; full: plus deterministic phrasing variants")
     parser.add_argument("--allow-download", action="store_true", help="allow the real model to be fetched once")
+    parser.add_argument("--domains", action="store_true", help="show per-domain breakdown")
     parser.add_argument("--json", action="store_true")
     args = parser.parse_args()
 
@@ -160,38 +166,42 @@ def main() -> int:
             )
             return 2
 
+    corpus = build_corpus()
+    cases = build_cases(expand=(args.suite == "full"))
+    classify_cases(cases, corpus)
+    authored = sum(1 for case in cases if case["authored"] == "yes")
+
     with tempfile.TemporaryDirectory() as temp:
         root = Path(temp)
-        report = {
+        report: dict[str, object] = {
+            "suite": args.suite,
             "mode": args.mode,
-            "lexical_baseline": {
-                "lexical_queries": run_cases(LEXICAL_CASES, None, root),
-                "paraphrase_queries": run_cases(PARAPHRASE_CASES, None, root),
-            },
-            "hybrid": {
-                "lexical_queries": run_cases(LEXICAL_CASES, embedder, root),
-                "paraphrase_queries": run_cases(PARAPHRASE_CASES, embedder, root),
-            } if embedder is not None else None,
+            "corpus_memories": len(corpus),
+            "total_cases": len(cases),
+            "authored_cases": authored,
+            "wrapped_variant_cases": len(cases) - authored,
+            "lexical_baseline": run_suite(cases, corpus, None, root),
+            "hybrid": run_suite(cases, corpus, embedder, root) if embedder is not None else None,
         }
 
     if args.json:
         print(json.dumps(report, indent=2))
     else:
-        print(f"Link recall quality eval (mode: {args.mode})")
-        for label, block in (("lexical-only", report["lexical_baseline"]), ("hybrid", report["hybrid"])):
-            if block is None:
-                continue
-            print(f"\n{label}:")
-            for group, stats in block.items():
-                print(
-                    f"  {group:20s} hit@1 {stats['hit@1']:.2f}  hit@3 {stats['hit@3']:.2f}"
-                    f"  ({stats['cases']} cases)"
-                )
+        print(
+            f"Link recall benchmark — suite: {args.suite}, mode: {args.mode}, "
+            f"corpus: {report['corpus_memories']} memories, cases: {report['total_cases']} "
+            f"({authored} authored + {report['wrapped_variant_cases']} phrasing variants)"
+        )
+        _print_block("lexical-only", report["lexical_baseline"], args.domains)
+        if report["hybrid"] is not None:
+            _print_block("hybrid", report["hybrid"], args.domains)
 
     if report["hybrid"] is not None:
-        for group in ("lexical_queries", "paraphrase_queries"):
-            for metric in ("hit@1", "hit@3"):
-                if report["hybrid"][group][metric] < report["lexical_baseline"][group][metric]:
+        baseline_groups = report["lexical_baseline"]["groups"]
+        hybrid_groups = report["hybrid"]["groups"]
+        for group, baseline in baseline_groups.items():
+            for metric in ("hit@1", "hit@3", "hit@5", "mrr@5"):
+                if hybrid_groups[group][metric] < baseline[metric]:
                     print(f"REGRESSION: hybrid {group} {metric} below lexical baseline", file=sys.stderr)
                     return 1
     return 0
diff --git a/scripts/recall_dataset.py b/scripts/recall_dataset.py
new file mode 100644
index 00000000..1cfe0694
--- /dev/null
+++ b/scripts/recall_dataset.py
@@ -0,0 +1,376 @@
+"""Benchmark dataset for Link memory recall quality.
+
+Deterministic and fully auditable: every memory and query is authored text in
+this file — no LLM, no network, no random generation. Each intent contributes
+one memory plus several queries. Queries are NOT trusted to be "lexical" or
+"paraphrase" by authorship; the benchmark runner classifies each query by its
+actual significant-token overlap with the target memory, so the reported
+paraphrase group provably shares no significant stemmed token with its target.
+
+Distractor memories (no queries of their own) grow the corpus so ranking is
+measured against realistic competition rather than a handful of candidates.
+"""
+from __future__ import annotations
+
+# (name, domain, title, tldr, body, queries)
+# Write queries in natural developer voice; mix token-overlapping phrasings
+# and zero-overlap paraphrases. ~7 queries per intent.
+INTENTS: list[tuple[str, str, str, str, str, list[str]]] = [
+    # ── tooling ──────────────────────────────────────────────────────────
+    ("ruff-linting", "tooling", "Ruff is the Python linter",
+     "Python linting uses Ruff; flake8 and pylint were retired.",
+     "All Python linting goes through Ruff with the repo config. flake8 and pylint were removed in the cleanup.",
+     ["ruff linting", "which linter do we use", "ruff config",
+      "what checks my python code style", "the tool that flags style problems in our code",
+      "did we keep flake8", "what runs over the codebase to catch style issues"]),
+    ("uv-package-manager", "tooling", "uv manages Python packages",
+     "Use uv instead of pip for installing and locking dependencies.",
+     "Dependency management uses uv: uv add for new packages, uv lock for the lockfile. Plain pip is only for one-off experiments.",
+     ["uv package manager", "how do we install dependencies", "uv lock workflow",
+      "what do I use to pull in a new library", "adding a third party module to the project",
+      "is plain pip allowed", "how are our requirements pinned"]),
+    ("pytest-over-unittest", "tooling", "pytest for new tests",
+     "New tests use pytest style, not unittest classes.",
+     "The team prefers pytest for new tests: plain functions, fixtures, and parametrize instead of unittest.TestCase classes.",
+     ["pytest over unittest", "which test framework", "pytest fixtures preference",
+      "how should I write new test cases", "the style for checking behavior in code we add",
+      "are TestCase classes ok", "what does the team want for verifying new features"]),
+    ("prettier-formatting", "tooling", "Prettier formats the frontend",
+     "All JS/TS formatting is Prettier with the checked-in config.",
+     "Frontend code is formatted by Prettier using the repo .prettierrc; never hand-format or argue style in review.",
+     ["prettier formatting", "how is javascript formatted", "prettier config location",
+      "what keeps the frontend code style consistent", "tool that rewrites my typescript layout",
+      "should style comments go in code review", "who decides whitespace in the web code"]),
+    ("make-targets", "tooling", "Make targets drive common tasks",
+     "Use make test, make lint, make dev instead of raw commands.",
+     "Common workflows are wrapped in Makefile targets: make test, make lint, make dev. Raw commands drift from CI.",
+     ["make targets", "makefile commands", "make test lint dev",
+      "the shortcuts for running everyday project chores", "how do I start the local development loop",
+      "what wraps our common shell invocations", "is there a single entry point for routine jobs"]),
+    ("node-version", "tooling", "Node 22 LTS is required",
+     "The frontend builds on Node 22 LTS; older majors fail.",
+     "Builds require Node 22 LTS. Engines are pinned in package.json and CI fails on older majors.",
+     ["node version", "which node do we build with", "node 22 requirement",
+      "what javascript runtime release must be installed", "my frontend build fails on an old runtime",
+      "minimum engine for the web build", "runtime prerequisite for compiling the ui"]),
+    ("docker-compose-dev", "tooling", "docker compose runs local services",
+     "Local Postgres and Redis come from docker compose up.",
+     "Local development services (Postgres, Redis) run via docker compose up; never install them directly on the laptop.",
+     ["docker compose dev", "how do I run local services", "compose up postgres redis",
+      "getting the database running on my machine", "spin up the supporting backends for hacking locally",
+      "should I brew install the datastore", "local copies of the storage services"]),
+    ("precommit-hooks", "tooling", "pre-commit runs before every commit",
+     "Install pre-commit; it runs lint and format on staged files.",
+     "The repo uses pre-commit hooks that lint and format staged files; install them with make setup once per clone.",
+     ["pre-commit hooks", "what runs before a commit", "pre-commit install",
+      "the thing that cleans files as I check them in", "automatic checks when saving work to git",
+      "why did my commit get rewritten", "setup step after cloning the repository"]),
+    # ── git/process ─────────────────────────────────────────────────────
+    ("commit-style", "process", "Commit and PR structure",
+     "Small commits; PR description starts with a one-paragraph summary.",
+     "The user prefers small, focused commits and pull requests whose description opens with a one-paragraph summary followed by bullets.",
+     ["commit style", "pr description format", "small commits preference",
+      "how should I structure my pull requests", "the shape reviewers expect for proposed changes",
+      "what goes at the top when I send work for review", "how granular should my checkpoints be"]),
+    ("deploy-from-main", "process", "Deploy only from main",
+     "Production releases ship only from the main branch after CI.",
+     "Releases ship only from the main branch after CI passes; never deploy from feature branches.",
+     ["deploy from main", "which branch do we release from", "main branch deploys",
+      "which branch do we ship production builds from", "where do live rollouts originate",
+      "can I push my feature straight to prod", "the source of truth for what customers run"]),
+    ("release-branch-naming", "process", "Release branches are release/x.y.z",
+     "Cut release branches named release/x.y.z from main.",
+     "Release preparation happens on branches named release/x.y.z cut from main; tags are created there.",
+     ["release branch naming", "release/x.y.z convention", "how are release branches named",
+      "what do I call the branch when cutting a version", "the naming scheme for shipping a new build",
+      "branch label before tagging", "convention for version preparation work"]),
+    ("review-before-merge", "process", "Review required before merge",
+     "Every PR needs at least one approving review.",
+     "Every pull request needs at least one review pass with approval before merging to the default branch.",
+     ["review before merge", "pr approval required", "how many reviews per pr",
+      "can I land this change without another set of eyes", "merging work nobody else looked at",
+      "who signs off before code goes in", "is a second person needed to accept my patch"]),
+    ("squash-merge", "process", "Squash-merge pull requests",
+     "PRs are squash-merged so main stays linear.",
+     "Pull requests are squash-merged; main history stays linear with one commit per PR.",
+     ["squash merge", "merge strategy for prs", "linear history main",
+      "what happens to my many little commits when the pr lands", "how does the trunk history stay tidy",
+      "do merge commits appear on the default branch", "the collapse policy when accepting changes"]),
+    ("conventional-commits", "process", "Conventional commit messages",
+     "Commit subjects follow feat:/fix:/docs: prefixes.",
+     "Commit messages follow Conventional Commits: feat:, fix:, docs:, chore: prefixes with imperative subjects.",
+     ["conventional commits", "commit message prefixes", "feat fix docs chore",
+      "the labeling scheme at the start of change descriptions", "how do I word the subject line of a checkpoint",
+      "grammar for messages in version history", "standard for describing what a change does"]),
+    ("no-force-push", "process", "Never force-push shared branches",
+     "Force-pushing main or develop is forbidden.",
+     "Never force-push shared branches (main, develop); rewriting published history breaks everyone's clones.",
+     ["no force push", "force push policy", "rewriting shared branches",
+      "can I overwrite the remote history others pull from", "rules about rewriting what teammates already fetched",
+      "why did my history rewrite get reverted", "is amending published work allowed"]),
+    ("issue-first", "process", "Open an issue before big changes",
+     "Significant work starts with a tracking issue and discussion.",
+     "Significant changes start with a tracking issue describing the problem and approach before any code is written.",
+     ["issue first workflow", "tracking issue before pr", "open issue for big changes",
+      "what comes before writing code for a large feature", "where do we debate an approach before building it",
+      "paperwork prior to a major refactor", "the step before investing days of work"]),
+    # ── infra/deploy ────────────────────────────────────────────────────
+    ("staging-env", "infra", "Staging mirrors production",
+     "Every change bakes on staging before production rollout.",
+     "Changes deploy to the staging environment first and bake for a day before production rollout.",
+     ["staging environment", "staging before production", "bake time on staging",
+      "where does code sit before customers see it", "the rehearsal copy of our live system",
+      "how long does a change wait before going live", "the environment between my laptop and prod"]),
+    ("rollback-procedure", "infra", "Rollback via redeploy of last tag",
+     "Roll back by redeploying the previous tagged release.",
+     "Rollbacks redeploy the previous tagged release; never hotfix directly on production hosts.",
+     ["rollback procedure", "how to roll back a release", "redeploy previous tag",
+      "undoing a bad ship to customers", "the escape hatch when a rollout goes wrong",
+      "can I ssh into prod and patch it", "recovering after a broken deployment"]),
+    ("secrets-in-vault", "infra", "Secrets live in Vault",
+     "API keys and credentials come from Vault, never env files.",
+     "All credentials and API keys live in Vault and are injected at deploy time; committed .env files are forbidden.",
+     ["secrets in vault", "where are api keys stored", "vault credentials",
+      "the place passwords and tokens are kept", "how does the app get its private keys at runtime",
+      "can I commit an env file with credentials", "storage for sensitive configuration values"]),
+    ("terraform-infra", "infra", "Infrastructure is Terraform",
+     "All cloud resources are managed in the terraform/ directory.",
+     "Cloud infrastructure is defined in Terraform under terraform/; console changes get reverted by the next apply.",
+     ["terraform infrastructure", "infra as code", "terraform directory",
+      "how are our cloud resources defined", "editing servers by clicking the web console",
+      "the declarative description of our hosting", "where compute and networking are specified"]),
+    ("oncall-rotation", "infra", "Weekly on-call rotation",
+     "On-call rotates weekly; handoff notes go in the runbook.",
+     "On-call rotates weekly on Mondays; the outgoing person writes handoff notes in the runbook.",
+     ["oncall rotation", "who is on call", "weekly oncall handoff",
+      "the schedule for who answers pages", "when does incident duty switch people",
+      "notes passed between shifts of production duty", "how often does alert ownership change"]),
+    ("logs-in-grafana", "infra", "Logs and dashboards in Grafana",
+     "Production logs and metrics are viewed through Grafana.",
+     "Production observability lives in Grafana: logs via Loki, metrics via Prometheus dashboards.",
+     ["grafana logs", "where are production logs", "grafana dashboards metrics",
+      "how do I see what the live system is doing", "the place to look when something misbehaves in prod",
+      "viewer for runtime output of the service", "charts of system health over time"]),
+    # ── data/storage ────────────────────────────────────────────────────
+    ("sqlite-storage", "data", "SQLite for local storage",
+     "Local data lives in SQLite with FTS; no external DB services.",
+     "The project stores local data in SQLite with FTS enabled; no external database services.",
+     ["sqlite storage", "local database sqlite", "sqlite fts",
+      "what do we use to persist data on disk", "the file-based store holding app state",
+      "do we run a database server locally", "where do records live on the user's machine"]),
+    ("postgres-production", "data", "Postgres 16 in production",
+     "Production data lives in Postgres 16 on RDS.",
+     "Production uses Postgres 16 on RDS with pgbouncer in front; schema changes go through migrations only.",
+     ["postgres production", "production database", "postgres 16 rds",
+      "what holds customer records in the live system", "the relational store behind the deployed app",
+      "which engine keeps our persistent server-side state", "backend that answers our sql"]),
+    ("migrations-alembic", "data", "Schema changes via Alembic",
+     "Every schema change is an Alembic migration; no manual DDL.",
+     "Database schema changes are Alembic migrations checked into the repo; manual DDL against any environment is forbidden.",
+     ["alembic migrations", "schema change process", "database migrations",
+      "how do I add a column safely", "evolving the table layout without breaking things",
+      "can I run alter statements by hand", "the versioned path for structural data changes"]),
+    ("no-pii-logs", "data", "Never log PII",
+     "Emails, names, and tokens must never appear in logs.",
+     "Logs must never contain PII: no emails, names, addresses, or tokens. Use the redaction helpers before logging request data.",
+     ["no pii in logs", "pii logging policy", "redact personal data logs",
+      "what personal details are banned from our output streams", "can user emails show up in diagnostics",
+      "privacy rules for what the service writes about requests", "scrubbing sensitive fields before recording"]),
+    ("backups-nightly", "data", "Nightly encrypted backups",
+     "Databases back up nightly, encrypted, with 30-day retention.",
+     "Databases are backed up nightly with encryption at rest and 30-day retention; restores are tested monthly.",
+     ["nightly backups", "backup retention 30 days", "encrypted database backups",
+      "how often do we copy the data somewhere safe", "recovering data if the store is lost",
+      "the safety net for catastrophic data loss", "snapshot cadence for our records"]),
+    ("no-cloud-sync", "data", "Memory stays local",
+     "Agent memory stays in local Markdown; no cloud sync.",
+     "The project decided agent memory stays in local Markdown files with no cloud synchronization.",
+     ["no cloud sync", "local markdown memory", "memory stays local",
+      "does anything leave this machine", "is my information uploaded anywhere",
+      "where does remembered context physically live", "the privacy stance on syncing notes off device"]),
+    # ── preferences ─────────────────────────────────────────────────────
+    ("short-answers", "preference", "Short answers with sources",
+     "Keep answers short and cite the wiki pages they came from.",
+     "The user prefers short, direct answers that cite the wiki pages they came from.",
+     ["short answers", "answer style preference", "cite sources in answers",
+      "how verbose should my replies be", "the length people want when I respond",
+      "do I need to point at where facts came from", "tone and size expected in written responses"]),
+    ("release-notes-short", "preference", "Release notes stay short",
+     "Release notes are a few bullets, user-facing language only.",
+     "The user prefers release notes kept to a few bullets in user-facing language; no internal jargon or commit lists.",
+     ["short release notes", "release notes style", "release notes bullets",
+      "how much detail goes in the changelog customers read", "writing up what shipped for end users",
+      "should the announcement list every commit", "the voice for describing a new version publicly"]),
+    ("morning-syncs", "preference", "User prefers morning meetings",
+     "Schedule syncs before noon in the user's timezone.",
+     "The user prefers meetings scheduled in the morning, before noon local time; afternoons are deep-work blocks.",
+     ["morning meetings", "meeting time preference", "syncs before noon",
+      "when should I put things on the calendar", "the part of the day kept free for focus",
+      "best hour to book a discussion", "scheduling around the user's energy"]),
+    ("dark-theme", "preference", "Dark theme everywhere",
+     "The user runs dark mode in every tool and expects demos to match.",
+     "The user uses dark theme in every tool; screenshots and demos should be captured in dark mode.",
+     ["dark theme preference", "dark mode", "screenshots dark mode",
+      "which appearance do their tools use", "how should captured ui images look",
+      "light or dark for the demo recording", "the visual scheme on their machine"]),
+    ("tabs-vs-spaces", "preference", "Four-space indentation",
+     "Python and config files indent with four spaces, never tabs.",
+     "Indentation is four spaces everywhere; tab characters are rejected by the linter.",
+     ["four space indentation", "tabs vs spaces", "indent width",
+      "how far do nested blocks step in", "the whitespace convention inside files",
+      "will tab characters pass the checks", "layout rule for code depth"]),
+    ("typed-python", "preference", "Type hints required",
+     "New Python code carries full type annotations.",
+     "New Python functions carry full type annotations; untyped code is flagged in review.",
+     ["type hints required", "typed python", "annotations policy",
+      "do I have to declare what functions accept and return", "static typing expectations for new modules",
+      "will unannotated helpers pass review", "how strict are we about signatures"]),
+    ("english-docs", "preference", "Docs are written in English",
+     "All documentation and comments are in English.",
+     "Documentation, comments, and commit messages are written in English even though the team is multilingual.",
+     ["docs in english", "documentation language", "english comments",
+      "which tongue do we write manuals in", "language for explaining code to others",
+      "can I comment in my native language", "the lingua franca of the repository"]),
+    # ── project facts ───────────────────────────────────────────────────
+    ("python-versions", "project", "Supported Python versions",
+     "Support Python 3.10 through 3.14, all tested in CI.",
+     "The project supports Python 3.10 through 3.14 and tests all of them in CI.",
+     ["supported python versions", "python 3.10 to 3.14", "which python versions",
+      "which interpreter releases must keep working", "the oldest runtime we still promise to run on",
+      "compatibility window for the language runtime", "can I use syntax from the newest interpreter"]),
+    ("api-port-8080", "project", "API listens on 8080",
+     "The backend API serves on port 8080 locally.",
+     "The backend API listens on port 8080 in local development; the frontend proxies /api there.",
+     ["api port 8080", "which port backend", "local api port",
+      "where does the server accept requests on my machine", "the number after localhost for the backend",
+      "what does the web ui proxy its calls to", "socket the service binds during development"]),
+    ("license-mit", "project", "MIT licensed",
+     "The project is MIT licensed; dependencies must be compatible.",
+     "The project is MIT licensed; new dependencies must carry MIT-compatible licenses (no GPL).",
+     ["mit license", "project license", "license compatibility",
+      "the legal terms our code ships under", "can I add a copyleft dependency",
+      "what usage rights do downstream users get", "restrictions when vendoring third party code"]),
+    ("weekly-release", "project", "Releases ship weekly",
+     "A release train leaves every Thursday.",
+     "Releases ship weekly on Thursdays; anything not merged by Wednesday noon waits for the next train.",
+     ["weekly release thursday", "release cadence", "when do releases ship",
+      "how often does a new version go out", "the cutoff for making this week's ship",
+      "rhythm of delivering to customers", "if I merge friday when do users get it"]),
+    ("meeting-notes-obsidian", "project", "Meeting notes live in Obsidian",
+     "Meeting notes are kept in the Obsidian vault and imported to Link.",
+     "The user keeps meeting notes in an Obsidian vault and imports the relevant ones into Link.",
+     ["meeting notes obsidian", "obsidian vault notes", "where are meeting notes",
+      "where are the writeups from our sync calls", "the store of what was said in discussions",
+      "records of past conversations with the team", "place to find decisions from last week's call"]),
+    ("customer-sla", "project", "24-hour support SLA",
+     "Paid customers get first response within 24 hours.",
+     "Paid customers have a 24-hour first-response SLA on support tickets, business days only.",
+     ["support sla 24 hours", "customer sla", "first response time",
+      "how fast must we get back to paying users", "the promise on ticket turnaround",
+      "deadline for acknowledging a complaint", "response guarantee in the contract"]),
+    ("feature-flags", "project", "Features launch behind flags",
+     "New features roll out behind feature flags, off by default.",
+     "New features launch behind feature flags, default off, and are enabled progressively per cohort.",
+     ["feature flags", "launch behind flag", "flags default off",
+      "how do risky capabilities reach users gradually", "the switch controlling who sees new behavior",
+      "shipping something without turning it on for everyone", "progressive rollout mechanism"]),
+]
+
+# Distractor memories: realistic corpus filler with no benchmark queries.
+_DISTRACTOR_TOPICS = [
+    ("adr-records", "process", "Architecture decisions in ADRs",
+     "Significant architecture choices are recorded as ADR markdown files under docs/adr."),
+    ("browser-support", "project", "Browser support matrix",
+     "The web app supports the last two versions of Chrome, Firefox, Safari, and Edge."),
+    ("css-tailwind", "tooling", "Tailwind for styling",
+     "Frontend styling uses Tailwind utility classes; bespoke CSS files need a review exception."),
+    ("error-tracking-sentry", "infra", "Errors go to Sentry",
+     "Unhandled exceptions report to Sentry with release tagging and user-scrubbed context."),
+    ("i18n-later", "project", "Internationalization deferred",
+     "Internationalization is out of scope until the enterprise tier ships."),
+    ("jira-tickets", "process", "Work is tracked in Jira",
+     "All planned work is tracked as Jira tickets linked from pull requests."),
+    ("kafka-events", "data", "Events stream through Kafka",
+     "Cross-service events flow through Kafka topics with schema-registry enforced Avro."),
+    ("load-testing-k6", "infra", "Load tests use k6",
+     "Load testing runs k6 scripts from the perf/ directory before each major release."),
+    ("mobile-react-native", "project", "Mobile app is React Native",
+     "The mobile app is React Native with a shared TypeScript core."),
+    ("nginx-ingress", "infra", "NGINX terminates TLS",
+     "NGINX ingress terminates TLS and forwards plain HTTP to the app pods."),
+    ("openapi-spec", "project", "API described by OpenAPI",
+     "The public API is described by an OpenAPI 3.1 spec that generates the client SDKs."),
+    ("pagerduty-alerts", "infra", "Alerts page through PagerDuty",
+     "Critical alerts page the on-call engineer through PagerDuty; Slack is best-effort only."),
+    ("redis-caching", "data", "Redis caches hot reads",
+     "Hot read paths cache in Redis with 5-minute TTLs and explicit invalidation on writes."),
+    ("storybook-components", "tooling", "Components documented in Storybook",
+     "Shared UI components are documented and visually tested in Storybook."),
+    ("vpn-required", "infra", "VPN required for internal tools",
+     "Internal dashboards and admin tools are reachable only over the company VPN."),
+    ("weekly-demo", "process", "Friday demo ritual",
+     "Every Friday the team demos shipped work in a 30-minute open call."),
+    ("design-figma", "tooling", "Designs live in Figma",
+     "Product designs and prototypes live in Figma; engineers comment there, not in screenshots."),
+    ("analytics-posthog", "data", "Product analytics in PostHog",
+     "Product analytics events flow to self-hosted PostHog with anonymized user ids."),
+    ("code-owners", "process", "CODEOWNERS gates sensitive paths",
+     "Changes under auth/ and billing/ require approval from the owners listed in CODEOWNERS."),
+    ("changelog-keepachangelog", "process", "Changelog follows Keep a Changelog",
+     "CHANGELOG.md follows the Keep a Changelog format with an Unreleased section."),
+]
+
+
+def _memory(name: str, domain: str, title: str, tldr: str, body: str, memory_type: str = "preference") -> dict[str, object]:
+    return {
+        "name": name,
+        "title": title,
+        "tldr": tldr,
+        "tags": [domain],
+        "body": body,
+        "status": "active",
+        "scope": "user",
+        "memory_type": memory_type,
+        "review_status": "reviewed",
+        "domain": domain,
+    }
+
+
+# Deterministic phrasing wrappers applied to authored queries to grow the
+# suite with surface variation (word order and framing changes only; they are
+# counted separately from authored queries in reporting).
+_WRAPPERS = [
+    "{q}",
+    "quick question: {q}",
+    "remind me: {q}",
+    "for this project, {q}",
+]
+
+
+def build_corpus() -> list[dict[str, object]]:
+    memories = [
+        _memory(name, domain, title, tldr, body)
+        for name, domain, title, tldr, body, _queries in INTENTS
+    ]
+    memories.extend(
+        _memory(name, domain, title, body[:80], body)
+        for name, domain, title, body in _DISTRACTOR_TOPICS
+    )
+    return memories
+
+
+def build_cases(expand: bool = True) -> list[dict[str, str]]:
+    """Return benchmark cases: {query, target, domain, authored}."""
+    cases: list[dict[str, str]] = []
+    for name, domain, _title, _tldr, _body, queries in INTENTS:
+        for query in queries:
+            cases.append({"query": query, "target": name, "domain": domain, "authored": "yes"})
+            if expand:
+                for wrapper in _WRAPPERS[1:]:
+                    cases.append({
+                        "query": wrapper.format(q=query),
+                        "target": name,
+                        "domain": domain,
+                        "authored": "wrapped",
+                    })
+    return cases
diff --git a/tests/test_recall_benchmark.py b/tests/test_recall_benchmark.py
new file mode 100644
index 00000000..636960e2
--- /dev/null
+++ b/tests/test_recall_benchmark.py
@@ -0,0 +1,40 @@
+import json
+import subprocess
+import sys
+import unittest
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+class RecallBenchmarkTests(unittest.TestCase):
+    def test_small_fake_suite_passes_regression_gate(self):
+        completed = subprocess.run(
+            [sys.executable, str(ROOT / "scripts/eval_recall_quality.py"),
+             "--suite", "small", "--mode", "fake", "--json"],
+            capture_output=True, text=True, timeout=300,
+        )
+
+        self.assertEqual(completed.returncode, 0, completed.stderr or completed.stdout)
+        report = json.loads(completed.stdout)
+        self.assertGreaterEqual(report["corpus_memories"], 50)
+        self.assertGreaterEqual(report["authored_cases"], 250)
+        groups = report["lexical_baseline"]["groups"]
+        self.assertIn("token-overlap", groups)
+        self.assertIn("zero-overlap", groups)
+        # The paraphrase group must stay genuinely hard for lexical recall;
+        # if this rises, queries have drifted into token overlap.
+        self.assertLess(groups["zero-overlap"]["hit@1"], 0.2)
+        self.assertGreaterEqual(groups["zero-overlap"]["cases"], 50)
+
+    def test_full_suite_reaches_one_thousand_cases(self):
+        sys.path.insert(0, str(ROOT / "scripts"))
+        from recall_dataset import build_cases, build_corpus
+
+        self.assertGreaterEqual(len(build_cases(expand=True)), 1000)
+        self.assertGreaterEqual(len(build_corpus()), 50)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_semantic_core.py b/tests/test_semantic_core.py
index ea414049..dceffb84 100644
--- a/tests/test_semantic_core.py
+++ b/tests/test_semantic_core.py
@@ -23,9 +23,10 @@
 
 # Tiny deterministic embedder: maps known concepts onto fixed axes so
 # paraphrases ("structure my pull requests" / "commit style") land close
-# together without any model. Stopwords are dropped and unknown tokens get a
-# small hashed component so unrelated texts stay well below the cosine floor,
-# which is how a real embedding model behaves.
+# together without any model. It ABSTAINS on text it does not recognize
+# (zero vector), like an honest weak model: it can add signal only where it
+# has knowledge and can never inject ranking noise elsewhere. CI uses it to
+# exercise the full hybrid pipeline with a hard no-regression gate.
 _CONCEPTS = {
     0: {"commit", "commits", "committing", "pr", "prs", "pull", "requests", "structure", "structured", "style"},
     1: {"deploy", "deploys", "release", "releases", "ship", "shipping"},
@@ -51,8 +52,6 @@ def fake_embedder(texts: list[str]) -> list[list[float]]:
                 if token in concepts:
                     vector[axis] += 1.0
                     break
-            else:
-                vector[3 + (hash(token) % (_DIM - 3))] += 0.05
         vectors.append(vector)
     return vectors
 

From 6fa6ff0ced2f5f95cd8064d7c5e526615d77be01 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 01:20:18 -0600
Subject: [PATCH 05/25] Fix the three publication weaknesses: quality tier,
 third-party track, architecture-first positioning
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

1. Paraphrase recall: measured that static embeddings are the ceiling
   (retrieval-tuned potion-retrieval-32M and multi-view embeddings did not
   move zero-overlap results; ablations documented). Added a second local
   provider tier — fastembed all-MiniLM-L6-v2 (contextual ONNX) — preferred
   automatically when installed, with the static model kept as the
   instant-load fast tier for CLI and hooks. Quality tier on the full
   1,176-case suite: token-overlap hit@1 0.589 -> 0.749; zero-overlap
   paraphrase hit@3/hit@5 ~4x lexical (0.255/0.338); ~10 ms per recall.
   Offline guard verified empirically for both providers: a recall can
   never download a model.

2. Self-authored benchmark: added a third-party track. scripts/eval_locomo.py
   scores the retrieval stage of LoCoMo (ACL 2024) with turns as memories
   and evidence-annotated questions as queries — no LLM anywhere. Hybrid
   lifts any-evidence hit@10 0.578 -> 0.685 and evidence recall@10
   0.517 -> 0.608 across 1,536 third-party queries over 5,882 turns.
   Dataset downloaded by the user (CC BY-NC 4.0, Snap Inc.), never
   redistributed; the script contains no network code.

3. Positioning: rewrote docs/why-link.html to lead with the four
   architectural commitments (readable Markdown memory, review-gated
   writes, no LLM in the memory layer, CI-enforced zero network), with
   named Mem0/OpenMemory and Zep/Graphiti comparisons and the benchmark
   as supporting evidence. README and RESULTS.md updated with tiered and
   third-party numbers.
---
 CHANGELOG.md                      |   3 +
 README.md                         |  17 +--
 benchmarks/RESULTS.md             | 194 ++++++++++++++++--------------
 docs/why-link.html                |  17 ++-
 mcp_package/link_core/semantic.py | 126 +++++++++++++++----
 mcp_package/pyproject.toml        |   1 +
 scripts/eval_locomo.py            | 167 +++++++++++++++++++++++++
 tests/test_semantic_core.py       |  25 ++++
 8 files changed, 425 insertions(+), 125 deletions(-)
 create mode 100644 scripts/eval_locomo.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fcce2cdb..2dce7ffa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -20,6 +20,9 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 - Added a publication-grade recall benchmark: `scripts/recall_dataset.py` (62-memory corpus with distractors, 294 authored queries plus deterministic phrasing variants for 1,176 total cases, every query auto-classified by measured token overlap so the paraphrase group provably shares no significant stemmed token with its target) and `scripts/eval_recall_quality.py` (hit@1/3/5, MRR@5, per-domain breakdown, recall latency, JSON output, and a regression gate that fails if hybrid ever scores below lexical). CI runs the gate with a deterministic no-model embedder.
 - Published measured results in `benchmarks/RESULTS.md` with methodology, hardware, model-size ablation, honest limitations, and reproduction steps: hybrid recall lifts token-overlap hit@1 0.589 → 0.703 and doubles-to-triples zero-overlap paraphrase hit@3/hit@5, at ~2.8 ms per recall in-process.
 - Added `python3 -m link_mcp --semantic-setup` so MCP-only installs (no `lnk` CLI) can run the explicit one-time semantic model fetch and index build; the MCP server itself still never touches the network.
+- Added a second semantic tier: `pip install "link-mcp[semantic-quality]"` uses a local contextual ONNX model (all-MiniLM-L6-v2 via fastembed) and is preferred automatically when installed; the static-model fast tier remains for instant-load CLI and hook use, and `LINK_SEMANTIC_PROVIDER` picks explicitly. On the bundled benchmark the quality tier roughly quadruples pure-paraphrase hit@3/hit@5 over lexical recall. Ablations that did not survive measurement (retrieval-tuned static models, multi-view embeddings) are documented in `benchmarks/RESULTS.md`.
+- Added a third-party benchmark track: `scripts/eval_locomo.py` scores Link recall on the LoCoMo long-term conversational memory dataset (turns as memories, evidence-annotated questions as queries; retrieval stage only, no LLM anywhere). Hybrid recall lifts any-evidence hit@10 from 0.578 to 0.685 and evidence recall@10 from 0.517 to 0.608 over 1,536 third-party queries. The dataset (CC BY-NC 4.0, Snap Inc.) is downloaded by the user, never redistributed; the script contains no network code.
+- Rewrote the public "Why Link?" positioning around the four architectural commitments competitors cannot bolt on — readable Markdown memory, review-gated writes, no LLM in the memory layer, CI-enforced zero network — with named comparisons against Mem0/OpenMemory, Zep/Graphiti, and Letta, and the benchmark as supporting evidence.
 - Added `lnk hook session-start` to print the bounded session-start memory brief (readiness, relevant memories with confidence, pending review and capture state, and retrieval guidance) for agent hook runtimes; it scopes the brief to the hook's working directory project and never fails the agent session.
 - Added `lnk hook session-end` to turn an agent transcript into review-gated memory: it extracts bounded user/assistant text (skipping tool calls and outputs), skips trivial sessions, and stores proposal-only session notes through the same duplicate/conflict-safe capture path as `lnk session-end`.
 - Added idempotent, non-destructive session-hook writing to `~/.claude/settings.json` that preserves existing user hooks and settings, replaces only Link's own hook entries on rerun, and skips re-injection on session resume.
diff --git a/README.md b/README.md
index 85b62578..6f959c82 100644
--- a/README.md
+++ b/README.md
@@ -349,17 +349,20 @@ with no vector database, and semantic-only matches carry capped confidence
 labels so agents verify before trusting them.
 
 ```bash
-pip install "link-mcp[semantic]"
+pip install "link-mcp[semantic]"          # fast tier: tiny static model, instant load
+pip install "link-mcp[semantic-quality]"  # quality tier: contextual model, best recall
 lnk semantic ~/link --setup   # one-time model fetch, with your approval
-lnk semantic ~/link           # status: lexical only vs hybrid
+lnk semantic ~/link           # status: lexical only vs hybrid, active tier
 python3 -m link_mcp --semantic-setup --wiki ~/link/wiki   # MCP-only installs
 ```
 
-Measured, not asserted: on the bundled 1,176-case benchmark over a
-62-memory corpus, hybrid recall lifts token-overlap hit@1 from 0.589 to
-0.703 and roughly doubles-to-triples pure-paraphrase (zero token overlap)
-hit@3/hit@5, at ~2.8 ms per recall with no service or vector database.
-Full methodology, honest limitations, and reproduction steps:
+Measured, not asserted: on the bundled 1,176-case benchmark, the quality
+tier lifts token-overlap hit@1 from 0.589 to 0.749 and pure-paraphrase
+(zero token overlap) hit@3/hit@5 by ~4×, at ~10 ms per recall with no
+service or vector database. On the third-party LoCoMo retrieval track
+(1,536 evidence-annotated questions over 5,882 conversation turns), hybrid
+recall lifts any-evidence hit@10 from 0.578 to 0.685. Full methodology,
+honest limitations, and reproduction steps:
 [benchmarks/RESULTS.md](benchmarks/RESULTS.md).
 
 <details>
diff --git a/benchmarks/RESULTS.md b/benchmarks/RESULTS.md
index 5078dd56..b3919daa 100644
--- a/benchmarks/RESULTS.md
+++ b/benchmarks/RESULTS.md
@@ -2,116 +2,130 @@
 
 Link's recall is measured, not asserted. This document holds the current
 numbers, exactly how they were produced, and how to reproduce them on your
-own machine. The benchmark is deterministic and fully local: no LLM calls,
-no network, no randomness — every memory and query is authored text checked
-into this repository.
-
-## What is measured
-
-Given a personal-memory corpus and a query, Link's `recall` ranks memories.
-We measure whether the correct memory appears at rank 1 / top 3 / top 5
-(hit@1, hit@3, hit@5) and the mean reciprocal rank (MRR@5), comparing:
-
-- **lexical-only** — Link's default recall: token matching with stemming,
-  synonym groups, and rank boosts. Zero dependencies.
-- **hybrid** — lexical plus the optional local semantic layer
-  (`pip install "link-mcp[semantic]"`, model2vec `potion-base-8M`,
-  ~30 MB static embeddings, loaded offline-only).
-
-## Dataset
-
-`scripts/recall_dataset.py`:
-
-- **62 memories** across six domains (tooling, process, infra, data,
-  preferences, project facts), including 20 distractor memories with no
-  queries, so ranking competes against realistic noise. This corpus size
-  reflects real personal agent memory (dozens to hundreds of memories, not
-  millions of documents).
-- **1,176 cases** in the full suite: 294 authored queries (7 per intent,
-  mixing natural token-matching phrasings and true paraphrases) plus 882
-  deterministic phrasing variants ("quick question: …", "remind me: …") that
-  test framing robustness. The small suite (294 authored cases) is what CI
-  runs.
-- **Honest grouping**: queries are classified by *measured* overlap, not by
-  authorship. A query counts as `zero-overlap` only if it provably shares no
-  significant stemmed token with any text of its target memory — i.e. pure
-  paraphrases that token matching cannot reach directly.
-
-## Results
-
-Full suite (1,176 cases), model2vec potion-base-8M, Apple M4, macOS 26.5.1,
-Python 3.14. Run date: 2026-07-07, Link `develop` (post-1.5.0).
+own machine. There are two tracks:
 
-### Token-overlap queries (800 cases)
+1. **Link recall benchmark** — our own deterministic, fully auditable
+   dataset (checked into this repo; no LLM, no network, no randomness).
+2. **LoCoMo third-party track** — the retrieval stage of the long-term
+   conversational memory benchmark the hosted-memory industry quotes
+   (Maharana et al., ACL 2024, Snap Research), using only its third-party
+   questions and evidence annotations.
 
-| metric | lexical-only | hybrid | change |
-|---|---|---|---|
-| hit@1 | 0.589 | **0.703** | +11.4 pp |
-| hit@3 | 0.729 | **0.833** | +10.4 pp |
-| hit@5 | 0.815 | **0.880** | +6.5 pp |
-| MRR@5 | 0.668 | **0.769** | +0.101 |
+## Semantic tiers
 
-Semantic evidence helps even when tokens match: it disambiguates between
-several memories that share words with the query.
+Lexical recall is always the default and the fallback (zero dependencies).
+Two optional local semantic tiers upgrade it — both load offline-only at
+recall time, keep embeddings in plain JSON under `.link-cache/`, and use no
+vector database or service:
 
-### Zero-overlap queries — pure paraphrases (376 cases)
+| tier | install | model | load time | best for |
+|---|---|---|---|---|
+| fast | `pip install "link-mcp[semantic]"` | model2vec potion-base-8M (~30 MB) | ~0.1 s | CLI, session-start hooks |
+| quality | `pip install "link-mcp[semantic-quality]"` | all-MiniLM-L6-v2 ONNX (~90 MB) | ~5 s | MCP server, long-lived agents |
 
-| metric | lexical-only | hybrid | change |
-|---|---|---|---|
-| hit@1 | 0.048 | **0.074** | 1.5× |
-| hit@3 | 0.064 | **0.136** | 2.1× |
-| hit@5 | 0.082 | **0.202** | 2.5× |
-| MRR@5 | 0.058 | **0.115** | 2.0× |
+The quality tier is preferred automatically when installed
+(`LINK_SEMANTIC_PROVIDER` overrides).
 
-### Latency (per recall over the 62-memory corpus)
+## Track 1: Link recall benchmark
 
-| mode | p50 | p95 | mean |
-|---|---|---|---|
-| lexical-only | 1.33 ms | 1.85 ms | 1.32 ms |
-| hybrid | 2.76 ms | 3.31 ms | 2.79 ms |
+Dataset (`scripts/recall_dataset.py`): 62 memories across six domains
+including 20 distractors; 1,176 cases (294 authored queries + deterministic
+phrasing variants). Queries are grouped by *measured* overlap: a case counts
+as `zero-overlap` only if it provably shares no significant stemmed token
+with its target memory — pure paraphrases that token matching cannot reach.
 
-In-process, no service, no vector database. The one-time model load
-(~100 ms) is excluded; embedding-index refresh is incremental and
-content-hash keyed.
+Full suite, Apple M4, macOS 26.5.1, Python 3.14, run 2026-07-08, Link
+`develop` (post-1.5.0).
 
-### Model size ablation (authored 294-case suite)
+### Token-overlap queries (800 cases)
 
-| model | size | zero-overlap hit@3 | hit@5 | hybrid mean latency |
-|---|---|---|---|---|
-| none (lexical) | 0 | 0.064 | 0.074 | 1.15 ms |
-| potion-base-8M (default) | ~30 MB | 0.149 | 0.234 | 2.62 ms |
-| potion-base-32M | ~120 MB | 0.160 | 0.266 | 3.73 ms |
+| metric | lexical | fast tier | quality tier |
+|---|---|---|---|
+| hit@1 | 0.589 | 0.703 | **0.749** |
+| hit@3 | 0.729 | 0.833 | **0.886** |
+| hit@5 | 0.815 | 0.880 | **0.926** |
+| MRR@5 | 0.668 | 0.769 | **0.818** |
+
+### Zero-overlap queries — pure paraphrases (376 cases)
 
-The 32M model buys little over 8M on this task, which is why 8M is the
-default (`LINK_SEMANTIC_MODEL` overrides it).
+| metric | lexical | fast tier | quality tier |
+|---|---|---|---|
+| hit@1 | 0.048 | 0.074 | **0.120** (2.5×) |
+| hit@3 | 0.064 | 0.136 | **0.255** (4.0×) |
+| hit@5 | 0.082 | 0.202 | **0.338** (4.1×) |
+| MRR@5 | 0.058 | 0.115 | **0.191** (3.3×) |
+
+### Latency (per recall, 62-memory corpus, model load excluded)
+
+| mode | p50 | mean |
+|---|---|---|
+| lexical | 1.3 ms | 1.3 ms |
+| fast tier | 2.8 ms | 2.8 ms |
+| quality tier | 9.3 ms | 10.0 ms |
+
+### Ablations we ran and rejected
+
+- **potion-retrieval-32M** (retrieval-tuned static model) and **multi-view
+  embeddings** (title/tldr/body embedded separately, max-similarity): both
+  improved token-overlap slightly but did not move zero-overlap paraphrases.
+  The zero-overlap ceiling is the static-embedding paradigm itself, which is
+  why the quality tier uses a contextual model instead of a bigger static one.
+- **potion-base-32M**: marginal over 8M; not worth 4× the size as a default.
+
+## Track 2: LoCoMo third-party retrieval
+
+Every dialog turn of a LoCoMo conversation becomes one memory record; every
+evidence-annotated question (adversarial category excluded) becomes a recall
+query; we measure whether Link ranks the annotated evidence turns highly.
+10 conversations, 5,882 turn-memories (~590 per conversation), 1,536
+third-party queries. No LLM anywhere: this isolates the retrieval stage with
+third-party queries and third-party gold labels.
+
+| metric | lexical | hybrid (quality tier) |
+|---|---|---|
+| any-evidence hit@1 | 0.290 | **0.309** |
+| any-evidence hit@5 | 0.496 | **0.540** |
+| any-evidence hit@10 | 0.578 | **0.685** |
+| evidence recall@10 | 0.517 | **0.608** |
+| latency p50 / mean | 16 ms | 45 ms / 61 ms |
+
+**Not comparable to published LoCoMo QA scores** (mem0, Zep, etc. report
+end-to-end LLM answer quality with server-side pipelines). This track scores
+deterministic local ranking only — no answer generation, no LLM judging, no
+network. The dataset is CC BY-NC 4.0 © Snap Inc. and is not redistributed
+here; the script prints the download command.
 
 ## Honest limitations
 
-- **Pure paraphrases remain hard.** Hybrid recall doubles-to-triples
-  zero-overlap performance, but the majority of pure paraphrases still miss
-  the top 5 at this corpus size with a 30 MB static model. Link labels
-  every semantic-only match (`match: semantic`, capped confidence) so agents
-  verify before trusting — we consider honest uncertainty a feature, and we
-  publish the miss rate rather than hiding it.
-- **The dataset is authored by the Link project.** It was written before
-  tuning was finalized and the scoring gate fails the build if hybrid ever
-  regresses lexical, but it is not an independent third-party benchmark.
-  Contributions of adversarial cases are welcome — the format is five lines
-  per intent in `scripts/recall_dataset.py`.
-- **Not comparable to hosted-memory benchmark numbers** (e.g. DMR/LoCoMo
-  scores from cloud systems): those measure LLM answer quality with
-  server-side embeddings or knowledge graphs and per-ingestion LLM calls.
-  Link's benchmark measures deterministic local ranking with zero network
-  and zero LLM involvement — a different, stricter privacy contract.
+- **Pure paraphrases are much better, not solved.** The quality tier
+  quadruples zero-overlap hit@3/hit@5 over lexical, yet roughly two thirds
+  of pure paraphrases still miss the top 5 on our corpus. Link labels every
+  semantic-only match (`match: semantic`, capped confidence) so agents
+  verify before trusting — we publish the miss rate rather than hiding it.
+- **Track 1 is self-authored.** It is deterministic, auditable, and gated
+  against regressions in CI, but it was written by the Link project.
+  Track 2 exists precisely to complement it with third-party data;
+  adversarial case contributions to Track 1 are welcome (five lines per
+  intent in `scripts/recall_dataset.py`).
+- **The quality tier costs a ~5 s model load**, so short-lived CLI calls
+  and session-start hooks default to the fast tier unless you opt in.
 
 ## Reproduce
 
 ```bash
 git clone https://github.com/gowtham0992/link && cd link
-python3 -m venv /tmp/linkbench && /tmp/linkbench/bin/pip install model2vec
-/tmp/linkbench/bin/python scripts/eval_recall_quality.py --suite full --mode real --allow-download
-# lexical baseline only (no dependencies):
+
+# Track 1 (lexical baseline needs nothing):
 python3 scripts/eval_recall_quality.py --suite full --mode off
+python3 -m venv /tmp/linkbench
+/tmp/linkbench/bin/pip install model2vec            # fast tier
+/tmp/linkbench/bin/pip install fastembed            # quality tier (preferred when present)
+/tmp/linkbench/bin/python scripts/eval_recall_quality.py --suite full --mode real --allow-download
+
+# Track 2 (download the dataset yourself; CC BY-NC 4.0 © Snap Inc.):
+curl -L -o /tmp/locomo10.json https://raw.githubusercontent.com/snap-research/locomo/main/data/locomo10.json
+python3 scripts/eval_locomo.py /tmp/locomo10.json --mode off
+/tmp/linkbench/bin/python scripts/eval_locomo.py /tmp/locomo10.json --mode real
 ```
 
 `--mode fake` runs a deterministic no-model embedder; CI uses it with a
diff --git a/docs/why-link.html b/docs/why-link.html
index 625a6ac7..8583b219 100644
--- a/docs/why-link.html
+++ b/docs/why-link.html
@@ -47,6 +47,7 @@ <h1>Link is not a notes app. It is local memory for agents.</h1>
     <div class="section-inner doc-grid">
       <aside class="toc">
         <strong>On this page</strong>
+        <a href="#architecture">Architecture</a>
         <a href="#fit">Best fit</a>
         <a href="#loop">Session loop</a>
         <a href="#compare">How to choose</a>
@@ -55,6 +56,16 @@ <h1>Link is not a notes app. It is local memory for agents.</h1>
         <a href="#boundaries">Boundaries</a>
       </aside>
       <article class="doc-content">
+        <h2 id="architecture">The Architecture Is the Product</h2>
+        <p>Every other agent-memory system — Mem0/OpenMemory, Zep/Graphiti, Letta — stores memory as embeddings in a vector database or as an LLM-extracted graph. You cannot read your own memory, and a model sits inside the write path. Link made four architectural commitments that cannot be bolted onto those designs:</p>
+        <div class="grid two-up">
+          <article class="panel"><h3>Memory you can read</h3><p>Every memory is a plain Markdown file. Open it, grep it, git-diff it, back it up. If Link disappeared tomorrow, your memory is still yours.</p></article>
+          <article class="panel"><h3>Review-gated writes</h3><p>No durable memory is created without your approval. Agents propose; you decide. Automatic session hooks capture proposals — never facts.</p></article>
+          <article class="panel"><h3>No LLM in the memory layer</h3><p>Ingestion and recall are deterministic. An extraction model can hallucinate facts into a knowledge graph; Link's memory layer cannot, because there is no model in the write path.</p></article>
+          <article class="panel"><h3>Provably local</h3><p>CI blocks outbound network code in the runtime. The optional semantic models load offline-only after one explicit setup. "Local-first" here is enforced, not promised.</p></article>
+        </div>
+        <p>Recall quality is measured, not asserted: a 1,176-case reproducible benchmark plus a third-party LoCoMo retrieval track, with published miss rates and a CI gate against regressions. See <a href="https://github.com/gowtham0992/link/blob/main/benchmarks/RESULTS.md">benchmarks/RESULTS.md</a>.</p>
+
         <h2 id="fit">Best Fit</h2>
         <p>Use Link when you want one local memory layer that multiple agents can share. It is strongest for developer and power-user workflows where privacy, provenance, and inspectable files matter.</p>
         <div class="grid two-up">
@@ -89,11 +100,11 @@ <h2 id="competitors">Compared With Alternatives</h2>
         <div class="choice-table">
           <div><strong>Alternative</strong><strong>Where Link wins</strong><strong>Where they win</strong></div>
           <div><span>Obsidian</span><span>Agent-ready memory lifecycle, MCP/CLI retrieval, validation, source-backed query packets.</span><span>Human-first note editing, mobile sync, plugins, and a mature visual graph.</span></div>
-          <div><span>Mem0</span><span>No hosted account, local Markdown storage, cross-agent desktop use, inspectable provenance.</span><span>Managed cloud APIs, hosted dashboards, and team/app integration primitives.</span></div>
+          <div><span>Mem0 / OpenMemory</span><span>Readable Markdown storage instead of a vector database, review-gated writes instead of silent extraction, no LLM in the memory layer, hooks-guaranteed session loop, published benchmark with miss rates.</span><span>Managed cloud APIs, hosted dashboards, larger community, and team/app integration primitives.</span></div>
           <div><span>Letta</span><span>Works beside existing agents instead of becoming the agent runtime; simpler local file model.</span><span>Full stateful-agent runtime, managed execution loop, and hosted deployment options.</span></div>
-          <div><span>Graphiti</span><span>Personal/project memory with reviewable Markdown and simple local operations.</span><span>Temporal knowledge graphs, automatic extraction, and enterprise graph use cases.</span></div>
+          <div><span>Zep / Graphiti</span><span>Deterministic memory with no LLM extraction cost or hallucination risk, reviewable Markdown, millisecond local recall, review/expiry lifecycle for time-sensitive memory.</span><span>Bi-temporal knowledge graphs, automatic entity extraction, multi-user business data, and enterprise graph use cases.</span></div>
           <div><span>Built-in agent memory</span><span>One memory layer shared across Codex, Claude, Cursor, Kiro, VS Code, Antigravity, and local agents.</span><span>Zero setup inside one vendor's product.</span></div>
-          <div><span>Plain RAG or vector search</span><span>Reviewable memory, source files, graph context, lifecycle controls, and bounded agent packets.</span><span>Semantic retrieval quality, embedding connectors, and application-specific pipelines.</span></div>
+          <div><span>Plain RAG or vector search</span><span>Reviewable memory, source files, graph context, lifecycle controls, bounded agent packets — plus optional local hybrid semantic recall with measured quality and honest confidence labels.</span><span>Cloud-scale embedding models, connectors, and application-specific pipelines over huge corpora.</span></div>
         </div>
 
         <h2 id="trust">Trust Model</h2>
diff --git a/mcp_package/link_core/semantic.py b/mcp_package/link_core/semantic.py
index b94301dc..3e868c15 100644
--- a/mcp_package/link_core/semantic.py
+++ b/mcp_package/link_core/semantic.py
@@ -52,16 +52,29 @@
 
 _MODEL_CACHE: dict[str, object] = {}
 
+# Two provider tiers, both fully local:
+# - "fastembed" (quality): contextual ONNX sentence embeddings. Best recall;
+#   ~5 s one-time model load, so it shines in long-lived processes like the
+#   MCP server. Preferred automatically when installed.
+# - "model2vec" (fast): tiny static embeddings. ~100 ms load, ideal for
+#   short-lived CLI calls and session-start hooks.
+SEMANTIC_PROVIDER_ENV = "LINK_SEMANTIC_PROVIDER"
+DEFAULT_FASTEMBED_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
 
-def semantic_model_name() -> str:
-    return os.environ.get(SEMANTIC_MODEL_ENV, "").strip() or DEFAULT_SEMANTIC_MODEL
 
+def _provider_override() -> str:
+    return os.environ.get(SEMANTIC_PROVIDER_ENV, "").strip().lower()
 
-def semantic_disabled() -> bool:
-    return os.environ.get(SEMANTIC_DISABLE_ENV, "").strip().lower() in {"0", "off", "false", "no"}
+
+def _fastembed_installed() -> bool:
+    try:
+        import fastembed  # noqa: F401
+    except Exception:
+        return False
+    return True
 
 
-def provider_installed() -> bool:
+def _model2vec_installed() -> bool:
     try:
         import model2vec  # noqa: F401
     except Exception:
@@ -69,38 +82,87 @@ def provider_installed() -> bool:
     return True
 
 
-def _load_model(allow_download: bool = False):
-    """Load the static embedding model; offline unless setup explicitly allows."""
-    model_name = semantic_model_name()
-    cache_key = f"{model_name}:{allow_download}"
-    cached = _MODEL_CACHE.get(model_name)
-    if cached is not None:
-        return cached
+def semantic_provider() -> str | None:
+    """Return the active provider name, or None when nothing is installed."""
+    override = _provider_override()
+    if override == "fastembed":
+        return "fastembed" if _fastembed_installed() else None
+    if override == "model2vec":
+        return "model2vec" if _model2vec_installed() else None
+    if _fastembed_installed():
+        return "fastembed"
+    if _model2vec_installed():
+        return "model2vec"
+    return None
+
+
+def semantic_model_name() -> str:
+    override = os.environ.get(SEMANTIC_MODEL_ENV, "").strip()
+    if override:
+        return override
+    if semantic_provider() == "fastembed":
+        return DEFAULT_FASTEMBED_MODEL
+    return DEFAULT_SEMANTIC_MODEL
+
+
+def semantic_model_key() -> str:
+    """Provider-qualified model id; changing provider or model rebuilds the index."""
+    return f"{semantic_provider() or 'none'}:{semantic_model_name()}"
+
+
+def semantic_disabled() -> bool:
+    return os.environ.get(SEMANTIC_DISABLE_ENV, "").strip().lower() in {"0", "off", "false", "no"}
+
+
+def provider_installed() -> bool:
+    return semantic_provider() is not None
+
+
+def _set_offline_guard(allow_download: bool) -> None:
     if not allow_download:
         # Force offline so recall can never silently reach the network.
         os.environ["HF_HUB_OFFLINE"] = "1"
     else:
         os.environ.pop("HF_HUB_OFFLINE", None)
-    from model2vec import StaticModel
 
-    model = StaticModel.from_pretrained(model_name)
-    _MODEL_CACHE[model_name] = model
-    del cache_key
+
+def _load_model(allow_download: bool = False):
+    """Load the embedding model; offline unless setup explicitly allows."""
+    provider = semantic_provider()
+    model_name = semantic_model_name()
+    cache_key = f"{provider}:{model_name}"
+    cached = _MODEL_CACHE.get(cache_key)
+    if cached is not None:
+        return cached
+    _set_offline_guard(allow_download)
+    if provider == "fastembed":
+        from fastembed import TextEmbedding
+
+        model = TextEmbedding(model_name)
+    else:
+        from model2vec import StaticModel
+
+        model = StaticModel.from_pretrained(model_name)
+    _MODEL_CACHE[cache_key] = model
     return model
 
 
 def load_embedder(allow_download: bool = False) -> Embedder | None:
     """Return a batch embedding callable, or None when unavailable."""
-    if semantic_disabled() or not provider_installed():
+    provider = semantic_provider()
+    if semantic_disabled() or provider is None:
         return None
     try:
         model = _load_model(allow_download=allow_download)
     except Exception:
         return None
 
-    def _embed(texts: list[str]) -> list[list[float]]:
-        vectors = model.encode(texts)
-        return [[float(value) for value in vector] for vector in vectors]
+    if provider == "fastembed":
+        def _embed(texts: list[str]) -> list[list[float]]:
+            return [[float(value) for value in vector] for vector in model.embed(texts)]
+    else:
+        def _embed(texts: list[str]) -> list[list[float]]:
+            return [[float(value) for value in vector] for vector in model.encode(texts)]
 
     return _embed
 
@@ -165,7 +227,7 @@ def refresh_memory_index(
     model_name: str | None = None,
 ) -> dict[str, object]:
     """Embed new or changed memories; prune deleted ones. Returns the index."""
-    model = model_name or semantic_model_name()
+    model = model_name or semantic_model_key()
     path = semantic_index_path(root)
     index = _load_index(path)
     items = index.get("items") if isinstance(index.get("items"), dict) else {}
@@ -299,7 +361,8 @@ def build_semantic_status(
     command_target: str | Path = ".",
 ) -> dict[str, object]:
     """Readiness report for the optional semantic recall layer."""
-    installed = provider_installed()
+    provider = semantic_provider()
+    installed = provider is not None
     disabled = semantic_disabled()
     ready = False
     index_items = 0
@@ -314,17 +377,29 @@ def build_semantic_status(
     if disabled:
         next_actions.append(f"unset {SEMANTIC_DISABLE_ENV} to re-enable semantic recall")
     elif not installed:
-        next_actions.append('pip install "link-mcp[semantic]"')
+        next_actions.append('pip install "link-mcp[semantic]"  # fast tier (tiny static model)')
+        next_actions.append('pip install "link-mcp[semantic-quality]"  # quality tier (contextual model)')
         next_actions.append(f"lnk semantic {command_target} --setup")
     elif not ready:
         next_actions.append(f"lnk semantic {command_target} --setup")
     elif index_items < memory_count:
         next_actions.append(f"lnk semantic {command_target} --rebuild")
+    if installed and provider == "model2vec" and not _fastembed_installed():
+        next_actions.append(
+            'optional quality upgrade: pip install "link-mcp[semantic-quality]" then rerun --setup'
+        )
+
+    tier = None
+    if provider == "fastembed":
+        tier = "quality (contextual embeddings; ~5s load, best for the MCP server)"
+    elif provider == "model2vec":
+        tier = "fast (static embeddings; instant load, best for CLI and hooks)"
 
     return {
         "enabled": ready,
         "disabled_by_env": disabled,
-        "provider": "model2vec" if installed else None,
+        "provider": provider,
+        "tier": tier,
         "model": semantic_model_name(),
         "model_available_offline": ready,
         "index_path": str(semantic_index_path(root)),
@@ -344,7 +419,8 @@ def render_semantic_status_text(payload: Mapping[str, object]) -> tuple[int, str
         "Link semantic recall",
         "",
         f"Mode: {payload.get('mode')}",
-        f"Provider: {payload.get('provider') or 'not installed'}",
+        f"Provider: {payload.get('provider') or 'not installed'}"
+        + (f" · {payload.get('tier')}" if payload.get("tier") else ""),
         f"Model: {payload.get('model')}",
         f"Indexed memories: {payload.get('indexed_memories')} of {payload.get('memory_count')}",
         f"Index: {payload.get('index_path')}",
diff --git a/mcp_package/pyproject.toml b/mcp_package/pyproject.toml
index a03f3364..1b46d8ee 100644
--- a/mcp_package/pyproject.toml
+++ b/mcp_package/pyproject.toml
@@ -26,6 +26,7 @@ classifiers = [
 
 [project.optional-dependencies]
 semantic = ["model2vec>=0.3"]
+semantic-quality = ["fastembed>=0.5"]
 
 [project.urls]
 Homepage = "https://github.com/gowtham0992/link"
diff --git a/scripts/eval_locomo.py b/scripts/eval_locomo.py
new file mode 100644
index 00000000..cef72da5
--- /dev/null
+++ b/scripts/eval_locomo.py
@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""Third-party retrieval track: LoCoMo evidence retrieval with Link recall.
+
+LoCoMo (Maharana et al., ACL 2024, Snap Research) is the long-term
+conversational memory benchmark the hosted-memory industry quotes. This track
+uses only its third-party ground truth — no LLM, no judging, no generation:
+
+- every dialog turn of a conversation becomes one Link memory record;
+- every evidence-annotated question becomes a recall query;
+- we measure whether Link's ranking returns the annotated evidence turns
+  (any-evidence hit@k and evidence recall@k), lexical vs hybrid.
+
+This is NOT the LoCoMo QA task (no answers are generated or scored), so the
+numbers are not comparable to end-to-end LLM QA scores quoted elsewhere; it
+isolates the retrieval stage with third-party queries and third-party gold
+labels over third-party conversations.
+
+Dataset: locomo10.json, CC BY-NC 4.0, (c) Snap Inc. Not redistributed here —
+download it yourself first (this script contains no network code):
+
+    curl -L -o /tmp/locomo10.json \
+        https://raw.githubusercontent.com/snap-research/locomo/main/data/locomo10.json
+
+Run:
+    python3 scripts/eval_locomo.py /tmp/locomo10.json --mode off    # lexical
+    python3 scripts/eval_locomo.py /tmp/locomo10.json --mode real   # hybrid
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import statistics
+import sys
+import tempfile
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "mcp_package"))
+
+from link_core.memory import recall_memories  # noqa: E402
+from link_core.semantic import load_embedder, semantic_memory_scores  # noqa: E402
+
+ADVERSARIAL_CATEGORY = 5
+
+
+def _turn_records(sample: dict) -> list[dict[str, object]]:
+    records: list[dict[str, object]] = []
+    conversation = sample["conversation"]
+    session = 1
+    while f"session_{session}" in conversation:
+        date = str(conversation.get(f"session_{session}_date_time") or "")
+        for turn in conversation[f"session_{session}"] or []:
+            text = str(turn.get("text") or "").strip() or str(turn.get("blip_caption") or "").strip()
+            if not text:
+                continue
+            records.append({
+                "name": str(turn.get("dia_id")),
+                "title": f"{turn.get('speaker')} (session {session})",
+                "tldr": date,
+                "tags": [],
+                "body": text,
+                "status": "active",
+                "scope": "user",
+                "memory_type": "fact",
+                "review_status": "reviewed",
+            })
+        session += 1
+    return records
+
+
+def _queries(sample: dict) -> list[dict[str, object]]:
+    queries = []
+    for qa in sample.get("qa", []):
+        if int(qa.get("category") or 0) == ADVERSARIAL_CATEGORY:
+            continue
+        evidence = qa.get("evidence") or []
+        if not isinstance(evidence, list) or not evidence:
+            continue
+        queries.append({"question": str(qa.get("question") or ""), "evidence": [str(e) for e in evidence]})
+    return queries
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("dataset", help="path to locomo10.json (see module docstring for the download command)")
+    parser.add_argument("--mode", choices=["off", "real"], default="off")
+    parser.add_argument("--k", type=int, default=10)
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args()
+
+    dataset_path = Path(args.dataset).expanduser()
+    if not dataset_path.exists():
+        print(f"Dataset not found: {dataset_path}", file=sys.stderr)
+        print("Download it first (CC BY-NC 4.0, (c) Snap Inc.):", file=sys.stderr)
+        print(
+            "  curl -L -o /tmp/locomo10.json "
+            "https://raw.githubusercontent.com/snap-research/locomo/main/data/locomo10.json",
+            file=sys.stderr,
+        )
+        return 2
+
+    embedder = None
+    if args.mode == "real":
+        embedder = load_embedder(allow_download=False)
+        if embedder is None:
+            print(
+                "Semantic model unavailable offline. Install a provider and run "
+                "`lnk semantic --setup` (or `python3 -m link_mcp --semantic-setup`) first.",
+                file=sys.stderr,
+            )
+            return 2
+
+    samples = json.loads(dataset_path.read_text(encoding="utf-8"))
+    k = max(1, args.k)
+    total_queries = 0
+    total_turns = 0
+    any_hits = {1: 0, 5: 0, k: 0}
+    evidence_recall: list[float] = []
+    latencies: list[float] = []
+
+    with tempfile.TemporaryDirectory() as temp:
+        for index, sample in enumerate(samples):
+            records = _turn_records(sample)
+            queries = _queries(sample)
+            total_turns += len(records)
+            root = Path(temp) / f"conv-{index}"
+            for query in queries:
+                started = time.perf_counter()
+                scores = (
+                    semantic_memory_scores(root, query["question"], records, embedder=embedder)
+                    if embedder is not None
+                    else None
+                )
+                results = recall_memories(records, query["question"], limit=k, semantic_scores=scores)
+                latencies.append((time.perf_counter() - started) * 1000)
+                names = [str(item["name"]) for item in results]
+                gold = set(query["evidence"])
+                for cutoff in any_hits:
+                    if gold & set(names[:cutoff]):
+                        any_hits[cutoff] += 1
+                evidence_recall.append(len(gold & set(names[:k])) / len(gold))
+                total_queries += 1
+
+    report = {
+        "dataset": "LoCoMo locomo10.json (CC BY-NC 4.0, Snap Inc.) — retrieval stage only",
+        "mode": args.mode,
+        "conversations": len(samples),
+        "turn_memories": total_turns,
+        "queries": total_queries,
+        "any_evidence_hit@1": round(any_hits[1] / total_queries, 4),
+        "any_evidence_hit@5": round(any_hits[5] / total_queries, 4),
+        f"any_evidence_hit@{k}": round(any_hits[k] / total_queries, 4),
+        f"evidence_recall@{k}": round(statistics.fmean(evidence_recall), 4),
+        "latency_ms_p50": round(statistics.median(latencies), 2),
+        "latency_ms_mean": round(statistics.fmean(latencies), 2),
+    }
+    if args.json:
+        print(json.dumps(report, indent=2))
+    else:
+        for key, value in report.items():
+            print(f"{key}: {value}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tests/test_semantic_core.py b/tests/test_semantic_core.py
index dceffb84..d22910cd 100644
--- a/tests/test_semantic_core.py
+++ b/tests/test_semantic_core.py
@@ -188,6 +188,31 @@ def test_confidence_cap(self):
         self.assertEqual(semantic_confidence_cap({"strength": 0.7}), "moderate")
         self.assertEqual(semantic_confidence_cap(None), "weak")
 
+    def test_provider_override_requires_installed_package(self):
+        import os
+        from link_core import semantic
+
+        # Neither provider package is installed in CI: overrides must not
+        # invent a provider, and detection must return None.
+        for override in ("fastembed", "model2vec"):
+            os.environ[semantic.SEMANTIC_PROVIDER_ENV] = override
+            try:
+                installed = (
+                    semantic._fastembed_installed() if override == "fastembed"
+                    else semantic._model2vec_installed()
+                )
+                if not installed:
+                    self.assertIsNone(semantic.semantic_provider())
+            finally:
+                os.environ.pop(semantic.SEMANTIC_PROVIDER_ENV, None)
+
+    def test_model_key_is_provider_qualified(self):
+        from link_core import semantic
+
+        key = semantic.semantic_model_key()
+        self.assertIn(":", key)
+        self.assertTrue(key.startswith(("none:", "fastembed:", "model2vec:")))
+
     def test_status_without_provider_reports_lexical_only(self):
         with tempfile.TemporaryDirectory() as temp:
             payload = build_semantic_status(Path(temp), memory_count=3, command_target=temp)

From 323b326d473343c6f23d0b32e2131be140d3b77b Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 08:03:19 -0600
Subject: [PATCH 06/25] Address post-1.5.0 audit findings: docs everywhere,
 upgrade guard, env guidance, loop consistency

- Documented hooks, semantic recall, and consolidation in every surface an
  external user or agent reads: PyPI package README, LINK.md, installed agent
  instructions (both variants), the MCP link://instructions resource, the
  docs landing page copy, and the CLI reference.
- connect/onboard --hooks now refresh a workspace runtime that predates
  session hooks (preview warns, --write repairs), preventing exit-2 hook
  noise after upgrades.
- lnk semantic now names the interpreter it checked and, when the Link MCP
  Python differs, prints the exact venv-side setup command
  (python -m link_mcp --semantic-setup), fixing the extras-in-the-wrong-env
  trap. Quality-tier setup states the ~5s CLI load tradeoff explicitly.
- The memory-backlog consolidation nudge moved into the core brief payload,
  so CLI start, MCP briefs, skills, and hooks all surface it consistently
  (and the hook no longer double-scans captures).
- lnk onboard gained --hooks; hook captures are titled with their project;
  consolidation groups near-duplicate captures by token overlap, not just
  exact matches; semantic status counts active memories only; Codex/Cursor
  hook support is labeled as new in output and docs.
---
 LINK.md                                       |  6 ++
 README.md                                     | 16 ++--
 docs/cli.html                                 |  4 +-
 docs/index.html                               |  2 +-
 .../_shared/link-instructions-project.md      |  3 +
 integrations/_shared/link-instructions.md     |  3 +
 link.py                                       | 87 ++++++++++++++-----
 mcp_package/README.md                         | 33 ++++++-
 mcp_package/link_core/agent_hooks.py          |  5 ++
 mcp_package/link_core/cli_parser.py           |  6 ++
 mcp_package/link_core/cli_runtime.py          | 25 +++++-
 mcp_package/link_core/consolidate.py          | 42 ++++++---
 mcp_package/link_core/memory.py               | 16 +++-
 mcp_package/link_core/semantic.py             |  3 +
 mcp_package/link_mcp/server.py                | 13 ++-
 15 files changed, 210 insertions(+), 54 deletions(-)

diff --git a/LINK.md b/LINK.md
index d3d1b584..d91360e6 100644
--- a/LINK.md
+++ b/LINK.md
@@ -623,3 +623,9 @@ If the wiki is empty, start here:
 If the wiki already exists, read `wiki/index.md` and `wiki/log.md` first to understand current state before doing anything.
 
 To verify MCP access, run `python3 link.py verify-mcp .` when `link.py` is available. It checks whether `link_mcp` imports in the configured Python and prints the MCP client config for the current wiki.
+
+## Memory Maintenance
+
+- **Session hooks.** Agents with hook support (Claude Code, Codex, Cursor) can install Link session hooks (`python3 link.py connect <agent> . --hooks --write`): the memory brief is injected automatically at session start and proposal-only session notes are stored at session end. Durable memory always requires review.
+- **Consolidation.** When briefs report a memory backlog (pending captures or reviews above threshold), run `python3 link.py consolidate .` (or MCP `review(action="consolidate")`) for a read-only plan with accept/discard/review commands. Apply actions only after the user approves each one.
+- **Semantic recall (optional, local).** With `link-mcp[semantic]` or `link-mcp[semantic-quality]` installed and a one-time `python3 link.py semantic . --setup`, recall also finds paraphrases. Recalled memories then carry `match: lexical|semantic|hybrid`; treat semantic-only matches as hints to verify, not facts.
diff --git a/README.md b/README.md
index 6f959c82..add06126 100644
--- a/README.md
+++ b/README.md
@@ -321,14 +321,14 @@ lnk verify-mcp ~/link
 ```
 
 For agents with session-hook support — Claude Code, Codex, and Cursor — add
-`--hooks` to make the memory loop automatic: session hooks inject a bounded
-Link memory brief at the start of every new session, and (where the agent has
-a session-end event) store proposal-only session notes at session end, so
-memory no longer depends on the agent remembering to call Link. Sessions with
-nothing memory-worthy are skipped, duplicate end events are deduplicated, and
-when the review backlog builds up the injected brief nudges the agent to offer
-a `lnk consolidate` pass. Durable memory still requires explicit review and
-approval; consolidation is a read-only plan.
+`--hooks` (works with `lnk onboard` too) to make the memory loop automatic:
+the brief is injected at session start and proposal-only notes are captured at
+session end, so memory no longer depends on the agent remembering to call
+Link. Empty sessions and duplicate end events are skipped, and when the
+backlog builds up the brief nudges the agent to offer a read-only
+`lnk consolidate` pass. Durable memory still requires your approval. Codex and
+Cursor hook support is new (wired to their documented schemas — report
+issues).
 
 ```bash
 lnk connect claude-code ~/link --hooks --write
diff --git a/docs/cli.html b/docs/cli.html
index bc56ef24..eb1579df 100644
--- a/docs/cli.html
+++ b/docs/cli.html
@@ -131,7 +131,7 @@ <h2 id="maintenance">Maintenance</h2>
 lnk connect kiro ~/link --write
 lnk connect claude-code ~/link --hooks --write
 lnk verify-mcp ~/link</code></pre>
-        <p>Add <code>--hooks</code> (Claude Code, Codex, Cursor) to also install session hooks: every new session then starts with a bounded Link memory brief injected automatically, and session end stores proposal-only notes with memory candidates for later review — no durable memory is written without approval. Codex has no session-end event, so it gets the session-start brief only. Sessions without memory-worthy content are skipped and duplicate end events are deduplicated, so the capture inbox does not fill with noise. The hooks run <code>lnk hook session-start</code> and <code>lnk hook session-end</code>, which you can also invoke directly to inspect what they inject or capture.</p>
+        <p>Add <code>--hooks</code> (Claude Code, Codex, Cursor) to also install session hooks: every new session then starts with a bounded Link memory brief injected automatically, and session end stores proposal-only notes with memory candidates for later review — no durable memory is written without approval. Codex has no session-end event, so it gets the session-start brief only. Sessions without memory-worthy content are skipped and duplicate end events are deduplicated, so the capture inbox does not fill with noise. The hooks run <code>lnk hook session-start</code> and <code>lnk hook session-end</code>, which you can also invoke directly to inspect what they inject or capture. Codex and Cursor hook support is new and follows those vendors' documented hook schemas — if a hook misbehaves there, please open an issue. If the workspace runtime predates session hooks, <code>--write</code> refreshes it automatically.</p>
         <p>Use <code>lnk consolidate</code> when the capture or review backlog builds up. It is read-only: it counts pending captures and memories needing review, groups duplicate captures, and prints paste-safe accept/discard/review commands to run with the user. When the backlog crosses a threshold, the injected session-start brief nudges the agent to offer a consolidation pass, and MCP agents can request the same plan through <code>review(action="consolidate")</code>.</p>
         <p>Use <code>lnk semantic</code> to inspect or enable optional hybrid recall. Lexical recall is always the default and the fallback; installing <code>pip install "link-mcp[semantic]"</code> and running <code>lnk semantic --setup</code> once (or <code>python3 -m link_mcp --semantic-setup</code> for MCP-only installs) adds a small local static-embedding model so paraphrased queries also find memories phrased differently. Recall itself never touches the network — the model loads offline-only, embeddings live in plain JSON under <code>.link-cache/</code>, and semantic-only matches are labeled with capped confidence so agents verify before trusting them. Measured results and methodology live in <code>benchmarks/RESULTS.md</code>.</p>
         <p>From a source checkout, use the synthetic large-wiki smoke when you want local scale evidence without touching your real wiki. The script prints the exact <code>lnk serve</code> command and graph URL for the generated fixture.</p>
@@ -142,7 +142,7 @@ <h2 id="all">All Commands</h2>
 lnk version
 lnk init [dir]
 lnk serve [dir] [--port 3000]
-lnk onboard [dir] [--agent codex] [--write] [--first-memory "..."] [--seed-project .]
+lnk onboard [dir] [--agent codex] [--write] [--hooks] [--first-memory "..."] [--seed-project .]
 lnk seed [project-dir] [dir] [--project-name name] [--overwrite] [--dry-run]
 lnk try [dir] [--force] [--serve] [--port 3000]
 lnk proof [dir] [--force] [--serve] [--port 3000]
diff --git a/docs/index.html b/docs/index.html
index ee4a8ca0..561c886f 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -184,7 +184,7 @@
   </script>
 
   <script type="__bundler/template">
-"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Most agent sessions start from zero. Link turns your notes, transcripts, and docs into an inspectable Markdown wiki — and explicit “remember this” requests into reviewable, source-backed memory that stays on your machine and works across every agent.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no embeddings<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, and forget workflows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share, instead of context trapped inside a single chat.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No external dependencies', desc: 'Pure Python. No vector databases, no embedding APIs, no npm.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
+"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Most agent sessions start from zero. Link turns your notes, transcripts, and docs into an inspectable Markdown wiki — and explicit “remember this” requests into reviewable, source-backed memory that stays on your machine and works across every agent.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no embeddings<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share, instead of context trapped inside a single chat.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No external dependencies', desc: 'Pure Python. No vector databases, no embedding APIs, no npm.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
   </script>
 <script>(function(){var T='Link \u2014 Local memory for AI agents',I='assets/favicon.svg';function e(){if(document.title!==T)document.title=T;if(!document.querySelector('link[rel=\"icon\"]')){var l=document.createElement('link');l.rel='icon';l.type='image/svg+xml';l.href=I;document.head.appendChild(l);}}e();document.addEventListener('DOMContentLoaded',e);window.addEventListener('load',function(){e();setTimeout(e,300);setTimeout(e,1200);});try{new MutationObserver(e).observe(document.head,{childList:true});}catch(_){}})();</script>
 </body>
diff --git a/integrations/_shared/link-instructions-project.md b/integrations/_shared/link-instructions-project.md
index 4bf258a4..0995a48d 100644
--- a/integrations/_shared/link-instructions-project.md
+++ b/integrations/_shared/link-instructions-project.md
@@ -33,6 +33,9 @@ After ingesting raw sources or making substantial wiki edits, use MCP `ingest` a
 When the user explicitly asks Link to remember something, use MCP `remember` when available. For uncertain or long-session memory, use MCP `admin` action `propose_memories` or `capture_session` first, then MCP `review` to inspect/approve.
 
 Use MCP `review` for memory inbox, profile, audit, log, explain, archive, restore, and forget workflows. Use MCP `admin` only for less-common maintenance and compatibility actions.
+If a memory brief reports a memory backlog (pending captures or reviews above threshold), offer the user a short consolidation pass: use MCP `review` with action `consolidate` when available, or run `python3 link.py consolidate`. The plan is read-only; apply its accept/discard/review commands only after the user approves each action.
+
+If Link session hooks are installed for this agent, the session-start memory brief is injected automatically — do not run a second startup recall; go straight to bounded task recall. Recalled memories carry a `match` field: treat `semantic` matches (paraphrase similarity with capped confidence) as hints to verify with the user, not facts to act on.
 
 When the user says **"remember"**, **"recall"**, **"ingest"**, **"query"**, **"lint"**, or **"research"**, read `LINK.md` for instructions and follow the protocol.
 
diff --git a/integrations/_shared/link-instructions.md b/integrations/_shared/link-instructions.md
index 341a5765..9f2781d9 100644
--- a/integrations/_shared/link-instructions.md
+++ b/integrations/_shared/link-instructions.md
@@ -27,6 +27,9 @@ When the user explicitly asks Link to remember something, use MCP `remember` whe
 At the end of a meaningful work session, propose memory instead of silently saving it. Use MCP `admin` action `session_end` with concise session notes when available, or run `lnk session-end <notes-or-transcript>`. Show the returned proposals to the user and save durable memory only after approval.
 
 Use MCP `review` for memory inbox, profile, audit, log, explain, archive, restore, and forget workflows. Use MCP `admin` only for less-common maintenance and compatibility actions.
+If a memory brief reports a memory backlog (pending captures or reviews above threshold), offer the user a short consolidation pass: use MCP `review` with action `consolidate` when available, or run `lnk consolidate`. The plan is read-only; apply its accept/discard/review commands only after the user approves each action.
+
+If Link session hooks are installed for this agent, the session-start memory brief is injected automatically — do not run a second startup recall; go straight to bounded task recall. Recalled memories carry a `match` field: treat `semantic` matches (paraphrase similarity with capped confidence) as hints to verify with the user, not facts to act on.
 
 When the user says **"remember"**, **"recall"**, **"ingest"**, **"query"**, **"lint"**, or **"research"**, read `~/link/LINK.md` for instructions and follow the protocol. Use terminal commands to access `~/link/` since it's outside the workspace.
 
diff --git a/link.py b/link.py
index 780763df..272b4d99 100644
--- a/link.py
+++ b/link.py
@@ -256,6 +256,7 @@
     check_link_mcp_import as _core_check_link_mcp_import,
     display_command as _core_display_command,
     render_mcp_verify_text as _core_render_mcp_verify_text,
+    resolve_mcp_python as _core_resolve_mcp_python,
     set_link_command_override as _core_set_link_command_override,
 )
 from link_core.mcp_connect import (
@@ -270,7 +271,6 @@
 )
 from link_core.consolidate import (
     build_consolidation_plan as _core_build_consolidation_plan,
-    memory_backlog_summary as _core_memory_backlog_summary,
     render_consolidate_text as _core_render_consolidate_text,
 )
 from link_core.semantic import (
@@ -279,6 +279,7 @@
     refresh_memory_index as _core_refresh_semantic_index,
     render_semantic_status_text as _core_render_semantic_status_text,
     semantic_memory_scores as _core_semantic_memory_scores,
+    semantic_provider as _core_semantic_provider,
 )
 from link_core.obsidian import (
     import_obsidian_vault as _core_import_obsidian_vault,
@@ -1907,6 +1908,7 @@ def start(
     brief_payload = _core_add_capture_review_to_brief(
         brief_payload,
         _capture_review_summary(target, project=project_name),
+        command_target=_resolve_link_root(target),
     )
     query_text = task or "your current task"
     relevant_count = int(brief_payload.get("relevant_count") or len(brief_payload.get("relevant_memories") or []))
@@ -1996,26 +1998,46 @@ def semantic(target: Path, setup: bool = False, rebuild: bool = False, json_outp
         print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
         return 1
     records = _memory_records(wiki_dir)
+    active_count = len([
+        record for record in records
+        if str(record.get("status") or "active").lower() == "active"
+    ])
     action_error = ""
     action_result = ""
     if setup or rebuild:
         if setup and not json_output:
             _print_text(
-                "Setting up semantic recall: this may download the local embedding model once "
-                "(a small static-embedding model, tens of MB). Recall itself never uses the network."
+                "Setting up semantic recall: this may download the local embedding model once. "
+                "Recall itself never uses the network."
             )
         embedder = _core_load_semantic_embedder(allow_download=setup)
         if embedder is None:
+            install_hint = f'{sys.executable} -m pip install "link-mcp[semantic]"'
             action_error = (
-                "Semantic provider unavailable. Install it first: pip install \"link-mcp[semantic]\""
+                f"Semantic provider unavailable for {sys.executable}. Install it first: {install_hint}"
                 if setup
                 else "Semantic model not available offline. Run: lnk semantic --setup"
             )
+            mcp_python = _core_resolve_mcp_python(target, wiki_dir, None, default_python=sys.executable)
+            if mcp_python != sys.executable:
+                action_error += (
+                    f"\nYour Link MCP Python is {mcp_python}. If you installed the extra there, "
+                    f"set it up through the MCP runtime instead: "
+                    f"{mcp_python} -m link_mcp --semantic-setup --wiki {wiki_dir}"
+                )
         else:
             index = _core_refresh_semantic_index(root, records, embedder=embedder)
             items = index.get("items") if isinstance(index.get("items"), dict) else {}
             action_result = f"Indexed {len(items)} memories."
-    payload = _core_build_semantic_status(root, memory_count=len(records), command_target=root)
+            if setup and _core_semantic_provider() == "fastembed":
+                action_result += (
+                    " Quality tier active: expect a ~5s model load per short-lived CLI command; "
+                    "the MCP server loads it once and stays fast. Prefer instant CLI recall? "
+                    "Set LINK_SEMANTIC_PROVIDER=model2vec (fast tier)."
+                )
+    payload = _core_build_semantic_status(
+        root, memory_count=active_count, command_target=root, python_cmd=sys.executable
+    )
     if action_result:
         payload["action_result"] = action_result
     if action_error:
@@ -2033,18 +2055,6 @@ def semantic(target: Path, setup: bool = False, rebuild: bool = False, json_outp
     return code
 
 
-def _memory_backlog_summary(target: Path, wiki_dir: Path) -> dict[str, object]:
-    """Workspace-wide backlog signal (unscoped: consolidation is a workspace chore)."""
-    root = _resolve_link_root(target)
-    captures = _capture_review_summary(target, project=None, limit=1)
-    inbox = _memory_inbox(wiki_dir, limit=50)
-    return _core_memory_backlog_summary(
-        capture_count=int(captures.get("count") or 0),
-        needs_review_count=int(inbox.get("review_count") or 0),
-        command_target=root,
-    )
-
-
 def consolidate(target: Path, limit: int = 50, project: str | None = None, json_output: bool = False) -> int:
     """Print a read-only consolidation plan for capture and review backlogs."""
     target = target.expanduser().resolve()
@@ -2109,6 +2119,7 @@ def _hook_session_start(
     brief_payload = _core_add_capture_review_to_brief(
         brief_payload,
         _capture_review_summary(target, project=project_name),
+        command_target=_resolve_link_root(target),
     )
     relevant_count = int(brief_payload.get("relevant_count") or len(brief_payload.get("relevant_memories") or []))
     project_seed_recommended = bool(status_payload.get("ready")) and not relevant_count and not int(
@@ -2121,7 +2132,7 @@ def _hook_session_start(
         "status": status_payload,
         "brief_text": brief_text,
         "project_seed_recommended": project_seed_recommended,
-        "backlog": _memory_backlog_summary(target, wiki_dir),
+        "backlog": brief_payload.get("backlog") or {},
     })
     _emit_session_start(text, emit)
     return 0
@@ -2175,7 +2186,7 @@ def _hook_session_end(target: Path, hook_event: dict[str, object], limit: int, p
     code = session_end(
         target,
         notes,
-        title="Agent session notes",
+        title="Agent session notes" + (f" — {project_name}" if project_name else ""),
         limit=proposal_limit,
         project=project_name,
     )
@@ -2325,7 +2336,21 @@ def connect_mcp(
     hooks_payload: dict[str, object] | None = None
     if hooks:
         runtime_script = target / "link.py"
-        if not runtime_script.exists():
+        runtime_note = ""
+        if runtime_script.exists():
+            # A workspace runtime copied before session hooks existed would
+            # make every installed hook fail with an argparse error.
+            if not (target / "link_core" / "agent_hooks.py").exists():
+                if write:
+                    _copy_runtime_files(target)
+                    runtime_note = f"Refreshed the Link runtime at {target}: it predated session hooks."
+                else:
+                    runtime_note = (
+                        f"The Link runtime at {target} predates session hooks; "
+                        "--write will refresh it automatically (or run "
+                        f"{_display_command(['lnk', 'init', str(target)])} first)."
+                    )
+        else:
             runtime_script = ROOT / "link.py"
         hooks_payload = _core_build_agent_hooks_payload(
             target=target,
@@ -2334,6 +2359,8 @@ def connect_mcp(
             python_cmd=sys.executable,
             write=write,
         )
+        if runtime_note:
+            hooks_payload["runtime_note"] = runtime_note
         payload["session_hooks"] = hooks_payload
 
     if json_output:
@@ -2382,6 +2409,7 @@ def onboard(
     agents: list[str] | None = None,
     all_agents: bool = False,
     write: bool = False,
+    hooks: bool = False,
     first_memory: str | None = None,
     seed_project: str | None = None,
     project: str | None = None,
@@ -2467,7 +2495,7 @@ def onboard(
     connections: list[dict[str, object]] = []
     for agent in _onboard_agent_names(agents, all_agents):
         try:
-            connections.append(_core_build_mcp_connect_payload(
+            connection = _core_build_mcp_connect_payload(
                 target=target,
                 wiki_dir=wiki_dir,
                 agent=agent,
@@ -2475,7 +2503,22 @@ def onboard(
                 init_command=[sys.executable, str(ROOT / "link.py"), "init", str(target)],
                 default_python=sys.executable,
                 write=write,
-            ))
+            )
+            if hooks and _core_supports_agent_hooks(agent):
+                connection["session_hooks"] = _core_build_agent_hooks_payload(
+                    target=target,
+                    agent=agent,
+                    runtime_script=(target / "link.py") if (target / "link.py").exists() else ROOT / "link.py",
+                    python_cmd=sys.executable,
+                    write=write,
+                )
+            elif hooks:
+                connection["session_hooks"] = {
+                    "agent": agent,
+                    "write": {"requested": False, "ok": False,
+                              "message": "session hooks are not available for this agent yet"},
+                }
+            connections.append(connection)
         except ValueError as exc:
             connections.append({
                 "agent": agent,
diff --git a/mcp_package/README.md b/mcp_package/README.md
index bbf86621..b236b808 100644
--- a/mcp_package/README.md
+++ b/mcp_package/README.md
@@ -112,7 +112,8 @@ New MCP configs should expose Link through six model-facing tools:
 3. `remember(text, ...)` writes only explicit user-approved durable memories.
 4. `ingest(action?, strict?)` checks or validates raw-source ingest work.
 5. `review(action?, ...)` handles memory inbox, profile, audit, log, explain,
-   archive, restore, forget, and visibility review workflows.
+   archive, restore, forget, visibility, and read-only `consolidate` (backlog
+   plan) review workflows.
 6. `admin(action, arguments?)` is the escape hatch for backup, migrate,
    validate, graph export, pages, captures, rebuilds, and advanced updates.
 
@@ -139,7 +140,8 @@ Slim agents should call:
 6. `remember(...)` only when the user explicitly approves saving durable memory.
 7. `admin(action="session_end", arguments="{...}")` at session end to propose memory without silently saving it.
 8. `review(action="inbox"|"audit"|"profile"|"explain"|...)` for memory lifecycle review.
-9. `admin(action, arguments)` for backup, migrate, validate, graph export, captures, rebuilds, and compatibility actions.
+9. `review(action="consolidate")` when a brief reports a memory backlog: it returns a read-only plan; apply its actions only after the user approves each one.
+10. `admin(action, arguments)` for backup, migrate, validate, graph export, captures, rebuilds, and compatibility actions.
 
 Add `review_after` for memories that should return to the review inbox after a
 date, or `expires_at` for temporary context that should leave default recall
@@ -152,6 +154,33 @@ terminal text.
 In the local web proposal picker, unreadable raw files are surfaced as
 `Fix access` instead of being loaded as empty proposal text.
 
+## Automatic Session Hooks
+
+Agents with session-hook support (Claude Code, Codex, Cursor) can run the
+memory loop automatically: `lnk connect <agent> --hooks --write` (from a Link
+checkout or installer) installs hooks that inject a bounded memory brief into
+every new session and store proposal-only session notes at session end.
+Sessions with nothing memory-worthy are skipped, duplicate end events are
+deduplicated, and durable memory still requires explicit review. If hooks are
+installed, agents should skip the manual startup brief call.
+
+## Optional Semantic Recall (still fully local)
+
+Lexical recall is the default and the fallback. Two optional local tiers add
+paraphrase recall:
+
+```bash
+pip install "link-mcp[semantic]"          # fast tier: tiny static model
+pip install "link-mcp[semantic-quality]"  # quality tier: contextual ONNX model
+python3 -m link_mcp --semantic-setup --wiki ~/link/wiki   # explicit one-time model fetch
+```
+
+The models load offline-only at recall time (a query can never trigger a
+download), embeddings live in plain JSON under `.link-cache/`, and there is no
+vector database or service. Semantic-only matches are labeled
+(`match: semantic`, capped confidence) so agents verify before trusting them.
+Measured results: <https://github.com/gowtham0992/link/blob/main/benchmarks/RESULTS.md>.
+
 ## Privacy and Scale
 
 - Local-first: `link-mcp` reads the wiki path you configure and does not call
diff --git a/mcp_package/link_core/agent_hooks.py b/mcp_package/link_core/agent_hooks.py
index 62778012..0a1aa0e6 100644
--- a/mcp_package/link_core/agent_hooks.py
+++ b/mcp_package/link_core/agent_hooks.py
@@ -296,6 +296,11 @@ def build_agent_hooks_payload(
             f"{config.display_name} has no session-end hook event; end sessions with `lnk session-end` "
             "or the MCP session_end action to capture memory proposals."
         )
+    if config.name in {"codex", "cursor"}:
+        behavior.append(
+            f"New: {config.display_name} hook support follows the vendor's documented schema; "
+            "if a hook misbehaves, please open an issue."
+        )
 
     return {
         "agent": config.name,
diff --git a/mcp_package/link_core/cli_parser.py b/mcp_package/link_core/cli_parser.py
index ea2a4f7a..36e7dae5 100644
--- a/mcp_package/link_core/cli_parser.py
+++ b/mcp_package/link_core/cli_parser.py
@@ -56,6 +56,11 @@ def build_cli_parser(
     onboard_cmd.add_argument("--agent", action="append", default=[], help="agent config to preview or write; repeatable")
     onboard_cmd.add_argument("--all-agents", action="store_true", help="preview or write all supported agent configs")
     onboard_cmd.add_argument("--write", action="store_true", help="update selected agent config files")
+    onboard_cmd.add_argument(
+        "--hooks",
+        action="store_true",
+        help="also configure session hooks for selected agents that support them (Claude Code, Codex, Cursor)",
+    )
     onboard_cmd.add_argument("--first-memory", default=None, help="seed one explicit memory for review")
     onboard_cmd.add_argument(
         "--seed-project",
@@ -447,6 +452,7 @@ def dispatch_cli_command(args: Any, handlers: Mapping[str, CliHandler]) -> int:
             agents=args.agent,
             all_agents=args.all_agents,
             write=args.write,
+            hooks=args.hooks,
             first_memory=args.first_memory,
             seed_project=args.seed_project,
             project=args.project,
diff --git a/mcp_package/link_core/cli_runtime.py b/mcp_package/link_core/cli_runtime.py
index 0ad28172..565bf1bc 100644
--- a/mcp_package/link_core/cli_runtime.py
+++ b/mcp_package/link_core/cli_runtime.py
@@ -122,6 +122,14 @@ def render_start_text(payload: Mapping[str, object]) -> tuple[int, str]:
             lines.append(f"- Need more context: {commands['query']}")
         if isinstance(commands, Mapping) and commands.get("review"):
             lines.append(f"- Review pending memory: {commands['review']}")
+        brief = payload.get("brief") if isinstance(payload.get("brief"), Mapping) else {}
+        backlog = brief.get("backlog") if isinstance(brief.get("backlog"), Mapping) else {}
+        if backlog.get("backlog"):
+            lines.append(
+                f"- Memory backlog ({backlog.get('pending_captures', 0)} captures · "
+                f"{backlog.get('needs_review_memories', 0)} reviews): offer a consolidation pass — "
+                f"{backlog.get('command')}"
+            )
         lines.append("- Save memory only after explicit user approval.")
     return 0 if status.get("ready") else 1, "\n".join(lines)
 
@@ -301,9 +309,19 @@ def _first_mapping_items(value: object, limit: int) -> list[Mapping[str, object]
 
 def _connection_state(connection: Mapping[str, object]) -> str:
     write_status = connection.get("write") if isinstance(connection.get("write"), Mapping) else {}
+    state = "preview"
     if write_status.get("requested"):
-        return "updated" if write_status.get("ok") else "failed"
-    return "preview"
+        state = "updated" if write_status.get("ok") else "failed"
+    session_hooks = connection.get("session_hooks")
+    if isinstance(session_hooks, Mapping):
+        hooks_write = session_hooks.get("write") if isinstance(session_hooks.get("write"), Mapping) else {}
+        if hooks_write.get("requested"):
+            state += " · hooks " + ("updated" if hooks_write.get("ok") else "failed")
+        elif hooks_write.get("message"):
+            state += f" · hooks: {hooks_write.get('message')}"
+        else:
+            state += " · hooks preview"
+    return state
 
 
 def render_onboard_text(payload: Mapping[str, object]) -> tuple[int, str]:
@@ -481,6 +499,9 @@ def render_agent_hooks_text(payload: Mapping[str, object]) -> tuple[int, str]:
     if isinstance(behavior, Sequence) and not isinstance(behavior, (str, bytes)):
         lines.append("")
         lines.extend(f"  {item}" for item in behavior)
+    runtime_note = str(payload.get("runtime_note") or "").strip()
+    if runtime_note:
+        lines.extend(["", f"  {runtime_note}"])
     lines.append("")
     if requested:
         lines.append(f"Write: {'updated' if ok else 'failed'}")
diff --git a/mcp_package/link_core/consolidate.py b/mcp_package/link_core/consolidate.py
index c018a898..2262b866 100644
--- a/mcp_package/link_core/consolidate.py
+++ b/mcp_package/link_core/consolidate.py
@@ -38,25 +38,39 @@ def memory_backlog_summary(
     }
 
 
-def _normalized_snippet(capture: dict[str, object]) -> str:
-    snippet = re.sub(r"\s+", " ", str(capture.get("snippet") or "")).strip().lower()
-    return snippet
+DUPLICATE_JACCARD = 0.8
+
+
+def _snippet_tokens(capture: dict[str, object]) -> set[str]:
+    snippet = str(capture.get("snippet") or "").lower()
+    return set(re.findall(r"[a-z0-9]{3,}", snippet))
 
 
 def _duplicate_capture_groups(captures: list[dict[str, object]]) -> list[dict[str, object]]:
-    """Group captures with identical normalized snippets; newest is kept."""
-    by_snippet: dict[str, list[dict[str, object]]] = {}
-    for capture in captures:
-        snippet = _normalized_snippet(capture)
-        if not snippet:
+    """Cluster near-duplicate captures by snippet token overlap; newest is kept.
+
+    Exact duplicates have Jaccard 1.0, so one similarity clustering covers
+    both identical and lightly reworded captures of the same session content.
+    """
+    clusters: list[dict[str, object]] = []
+    for capture in captures:  # capture_records sorts newest first
+        tokens = _snippet_tokens(capture)
+        if not tokens:
             continue
-        by_snippet.setdefault(snippet, []).append(capture)
+        for cluster in clusters:
+            keep_tokens: set[str] = cluster["tokens"]  # type: ignore[assignment]
+            union = tokens | keep_tokens
+            if union and len(tokens & keep_tokens) / len(union) >= DUPLICATE_JACCARD:
+                cluster["members"].append(capture)  # type: ignore[union-attr]
+                break
+        else:
+            clusters.append({"tokens": tokens, "keep": capture, "members": []})
     groups: list[dict[str, object]] = []
-    for snippet, members in by_snippet.items():
-        if len(members) < 2:
+    for cluster in clusters:
+        members = cluster["members"]
+        if not members:
             continue
-        # capture_records sorts newest first; keep the newest, mark the rest.
-        keep, *duplicates = members
+        keep = cluster["keep"]
         groups.append({
             "keep": {"path": keep.get("path"), "title": keep.get("title")},
             "duplicates": [
@@ -67,7 +81,7 @@ def _duplicate_capture_groups(captures: list[dict[str, object]]) -> list[dict[st
                     if isinstance(item.get("commands"), dict)
                     else "",
                 }
-                for item in duplicates
+                for item in members
             ],
         })
     return groups
diff --git a/mcp_package/link_core/memory.py b/mcp_package/link_core/memory.py
index 5fc8f040..19aaaf23 100644
--- a/mcp_package/link_core/memory.py
+++ b/mcp_package/link_core/memory.py
@@ -7,6 +7,7 @@
 from datetime import date, datetime, timezone
 from pathlib import Path
 
+from .consolidate import memory_backlog_summary
 from .files import atomic_write_text
 from .semantic import semantic_confidence_cap, semantic_match_points
 from .frontmatter import (
@@ -1776,8 +1777,9 @@ def memory_audit_next_actions(
 def add_capture_review_to_brief(
     payload: Mapping[str, object],
     captures: Mapping[str, object],
+    command_target: str | Path = ".",
 ) -> dict[str, object]:
-    """Attach raw-capture review state and guidance to a memory brief."""
+    """Attach raw-capture review state, backlog signal, and guidance to a brief."""
     result = dict(payload)
     capture_payload = dict(captures)
     guidance = [str(item) for item in result.get("agent_guidance", [])]
@@ -1794,6 +1796,18 @@ def add_capture_review_to_brief(
         guidance.append("Redact raw captures with secret warnings before sharing snippets or using their contents.")
     if read_warning_count:
         guidance.append("Fix unreadable raw captures before deciding whether capture memory should be accepted or deleted.")
+    review = result.get("review") if isinstance(result.get("review"), Mapping) else {}
+    backlog = memory_backlog_summary(
+        capture_count=capture_count,
+        needs_review_count=int(review.get("count") or 0),
+        command_target=command_target,
+    )
+    result["backlog"] = backlog
+    if backlog.get("backlog"):
+        guidance.append(
+            "The memory backlog is above threshold; offer the user a short consolidation pass "
+            f"({backlog.get('command')} prints a read-only plan with approve/discard commands)."
+        )
     result["agent_guidance"] = guidance
     return result
 
diff --git a/mcp_package/link_core/semantic.py b/mcp_package/link_core/semantic.py
index 3e868c15..f5e65427 100644
--- a/mcp_package/link_core/semantic.py
+++ b/mcp_package/link_core/semantic.py
@@ -359,6 +359,7 @@ def build_semantic_status(
     *,
     memory_count: int,
     command_target: str | Path = ".",
+    python_cmd: str | None = None,
 ) -> dict[str, object]:
     """Readiness report for the optional semantic recall layer."""
     provider = semantic_provider()
@@ -400,6 +401,7 @@ def build_semantic_status(
         "disabled_by_env": disabled,
         "provider": provider,
         "tier": tier,
+        "python": python_cmd,
         "model": semantic_model_name(),
         "model_available_offline": ready,
         "index_path": str(semantic_index_path(root)),
@@ -421,6 +423,7 @@ def render_semantic_status_text(payload: Mapping[str, object]) -> tuple[int, str
         f"Mode: {payload.get('mode')}",
         f"Provider: {payload.get('provider') or 'not installed'}"
         + (f" · {payload.get('tier')}" if payload.get("tier") else ""),
+        *( [f"Python: {payload.get('python')}"] if payload.get("python") else [] ),
         f"Model: {payload.get('model')}",
         f"Indexed memories: {payload.get('indexed_memories')} of {payload.get('memory_count')}",
         f"Index: {payload.get('index_path')}",
diff --git a/mcp_package/link_mcp/server.py b/mcp_package/link_mcp/server.py
index c947e3fb..87d92896 100644
--- a/mcp_package/link_mcp/server.py
+++ b/mcp_package/link_mcp/server.py
@@ -477,7 +477,9 @@ def _memory_brief(query: str = "", limit: int = 6, project: str = "") -> dict[st
         command_target=WIKI_DIR.parent,
         semantic_scores=_core_semantic_memory_scores(WIKI_DIR.parent, clean_query, records),
     )
-    return _core_add_capture_review_to_brief(payload, _capture_review_summary(project=project_name))
+    return _core_add_capture_review_to_brief(
+        payload, _capture_review_summary(project=project_name), command_target=WIKI_DIR.parent
+    )
 
 
 def _query_link(query: str, budget: str = "medium", project: str = "") -> dict[str, object]:
@@ -925,7 +927,14 @@ def link_instructions_resource() -> str:
         "6. At session end, use `admin(action=\"session_end\", arguments=\"{...}\")` or `capture_session` "
         "to save proposal-only notes for user review.\n"
         "7. Use `review` for inbox, explain, archive, restore, forget, profile, audit, and log workflows.\n"
-        "8. Use `admin` only for maintenance, graph/context expansion, pages, backups, migrations, and captures.\n\n"
+        "8. If a brief reports a memory backlog, offer the user a short consolidation pass: "
+        "`review(action=\"consolidate\")` returns a read-only plan; apply its accept/discard actions only "
+        "after the user approves each one.\n"
+        "9. Use `admin` only for maintenance, graph/context expansion, pages, backups, migrations, and captures.\n\n"
+        "If Link session hooks are installed for this agent, the startup brief is injected automatically — "
+        "skip step 2 and go straight to bounded task recall.\n"
+        "Recalled memories carry a `match` field: treat `semantic` matches (paraphrase similarity, capped "
+        "confidence) as hints to verify, not facts to act on.\n\n"
         "Never silently save durable memory. Prefer reviewed memories and source-backed wiki pages, and cite "
         "provenance when explaining why Link knows something.\n"
     )

From 784f911880d218c5368c1d122ff414d0b355dcac Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 08:08:08 -0600
Subject: [PATCH 07/25] Fix frictions found in a cold fresh-user walkthrough

Walked the product as a brand-new user (fresh clone, fake HOME, README
paths: proof -> onboard --hooks --write -> day-1/day-2 hook briefs ->
semantic status -> consolidate -> common mistakes) and fixed what hurt:

- Empty-workspace session-start briefs are now two actionable lines
  (seed project context, approval rule) instead of a fifteen-line
  skeleton of zeros injected into every new session on day one.
- Every 'Missing wiki directory' CLI error (25 sites) now prints a
  concrete next step: point at your workspace or lnk init here.
- Verified end-to-end in the walkthrough: onboard --hooks --write writes
  MCP config plus both hooks in one command; the stale-runtime guard
  warns in preview and repairs on write; day-2 briefs recall real
  memories; consolidate and semantic empty states read cleanly.
---
 CHANGELOG.md                         |  5 ++
 link.py                              | 89 ++++++++++++----------------
 mcp_package/link_core/cli_runtime.py | 14 +++++
 tests/test_link_cli.py               | 28 +++++++++
 4 files changed, 86 insertions(+), 50 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2dce7ffa..00fca53b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -23,6 +23,11 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 - Added a second semantic tier: `pip install "link-mcp[semantic-quality]"` uses a local contextual ONNX model (all-MiniLM-L6-v2 via fastembed) and is preferred automatically when installed; the static-model fast tier remains for instant-load CLI and hook use, and `LINK_SEMANTIC_PROVIDER` picks explicitly. On the bundled benchmark the quality tier roughly quadruples pure-paraphrase hit@3/hit@5 over lexical recall. Ablations that did not survive measurement (retrieval-tuned static models, multi-view embeddings) are documented in `benchmarks/RESULTS.md`.
 - Added a third-party benchmark track: `scripts/eval_locomo.py` scores Link recall on the LoCoMo long-term conversational memory dataset (turns as memories, evidence-annotated questions as queries; retrieval stage only, no LLM anywhere). Hybrid recall lifts any-evidence hit@10 from 0.578 to 0.685 and evidence recall@10 from 0.517 to 0.608 over 1,536 third-party queries. The dataset (CC BY-NC 4.0, Snap Inc.) is downloaded by the user, never redistributed; the script contains no network code.
 - Rewrote the public "Why Link?" positioning around the four architectural commitments competitors cannot bolt on — readable Markdown memory, review-gated writes, no LLM in the memory layer, CI-enforced zero network — with named comparisons against Mem0/OpenMemory, Zep/Graphiti, and Letta, and the benchmark as supporting evidence.
+- Added `lnk onboard --hooks` so the guided first-run path can install session hooks alongside MCP wiring, and made `connect`/`onboard --hooks --write` refresh workspace runtimes that predate session hooks (preview warns first), preventing broken hooks after upgrades.
+- Made the memory-backlog consolidation nudge part of the core brief payload so CLI `start`, MCP briefs, skills, and session hooks all surface it consistently.
+- Improved `lnk semantic` diagnostics: status names the Python interpreter being checked, and when the Link MCP Python differs, errors print the exact venv-side setup command; quality-tier setup states the ~5s short-lived-CLI load tradeoff explicitly.
+- Made the injected session-start brief compact for empty workspaces (two actionable lines instead of an empty statistics skeleton) and gave every missing-wiki CLI error a concrete next step instead of a dead end.
+- Titled automatic session captures with their project, clustered near-duplicate captures in consolidation plans by token overlap instead of exact text, and documented session hooks, semantic recall, and consolidation across the PyPI README, LINK.md, installed agent instructions, MCP instructions resource, and the docs site.
 - Added `lnk hook session-start` to print the bounded session-start memory brief (readiness, relevant memories with confidence, pending review and capture state, and retrieval guidance) for agent hook runtimes; it scopes the brief to the hook's working directory project and never fails the agent session.
 - Added `lnk hook session-end` to turn an agent transcript into review-gated memory: it extracts bounded user/assistant text (skipping tool calls and outputs), skips trivial sessions, and stores proposal-only session notes through the same duplicate/conflict-safe capture path as `lnk session-end`.
 - Added idempotent, non-destructive session-hook writing to `~/.claude/settings.json` that preserves existing user hooks and settings, replaces only Link's own hook entries on rerun, and skips re-injection on session resume.
diff --git a/link.py b/link.py
index 272b4d99..c666d61c 100644
--- a/link.py
+++ b/link.py
@@ -363,6 +363,18 @@ def _wiki_pages(wiki_dir: Path) -> list[Path]:
     )
 
 
+def _missing_wiki_error(wiki_dir: Path) -> int:
+    """Explain a missing wiki with a next step instead of a dead end."""
+    print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
+    print(
+        "Point Link at your workspace (for example: "
+        f"{_display_command(['lnk', 'status', str(Path.home() / 'link')])}) "
+        f"or create one here with {_display_command(['lnk', 'init', '.'])}.",
+        file=sys.stderr,
+    )
+    return 1
+
+
 def _resolve_wiki_dir(target: Path) -> Path:
     target = target.expanduser().resolve()
     if target.name == "wiki" and (target / "index.md").exists():
@@ -959,8 +971,7 @@ def team_sync(target: Path, remote: str | None = None, json_output: bool = False
 def share(target: Path, identifier: str, port: int = 3000, host: str = "127.0.0.1", json_output: bool = False) -> int:
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     payload = _core_share_page_payload(wiki_dir, identifier, host=host, port=port)
     return _emit_json_or_text(payload, json_output, _core_render_share_text, json_code=0 if payload.get("found") else 1)
 
@@ -1033,8 +1044,7 @@ def import_obsidian(
 def rebuild_backlinks(target: Path) -> int:
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     try:
         backlinks = _build_backlinks(wiki_dir)
     except OSError as exc:
@@ -1056,8 +1066,7 @@ def rebuild_backlinks(target: Path) -> int:
 def rebuild_index(target: Path) -> int:
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     try:
         result = _core_rebuild_index(wiki_dir)
     except OSError as exc:
@@ -1142,8 +1151,7 @@ def propose_memories(
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     text, source = _read_proposal_input(target, source_input)
     if not text.strip():
         print("Memory proposal input is required", file=sys.stderr)
@@ -1178,8 +1186,7 @@ def capture_session(
     root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
 
     text, source = _read_proposal_input(root, source_input)
     if not text.strip():
@@ -1247,8 +1254,7 @@ def session_end(
     root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
 
     text, source = _read_proposal_input(root, source_input)
     if not text.strip():
@@ -1324,8 +1330,7 @@ def capture_inbox(
     root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     payload = _core_capture_inbox(
         root,
         limit=limit,
@@ -1372,8 +1377,7 @@ def accept_capture(
     root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     try:
         selection = _core_capture_proposal_selection(
             root,
@@ -1457,8 +1461,7 @@ def redact_capture(
     root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     try:
         payload = _core_redact_capture_file(
             root,
@@ -1499,8 +1502,7 @@ def delete_capture(
     root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     try:
         payload = _core_delete_capture_file(root, capture, confirm=confirm)
     except ValueError:
@@ -1592,8 +1594,7 @@ def recall(
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     project_name = project or _default_project(target)
     results = _recall_memories(
         wiki_dir,
@@ -1656,8 +1657,7 @@ def forget_memory(target: Path, identifier: str, confirm: bool = False, json_out
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
 
     def rebuild_memory_backlinks() -> bool:
         backlinks = _build_backlinks(wiki_dir)
@@ -1701,8 +1701,7 @@ def memory_inbox(
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     inbox = _memory_inbox(wiki_dir, limit=limit, include_archived=include_archived, project=project)
 
     return _emit_json_or_text(
@@ -1720,8 +1719,7 @@ def memory_log(target: Path, limit: int = 50, include_captures: bool = True, jso
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     payload = _core_memory_log_payload(wiki_dir, limit=limit, include_captures=include_captures)
     return _emit_json_or_text(
         payload,
@@ -1734,8 +1732,7 @@ def memory_wins(target: Path, limit: int = 6, project: str | None = None, json_o
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     payload = _core_memory_wins_payload(wiki_dir, limit=limit, project=project)
     return _emit_json_or_text(
         payload,
@@ -1758,8 +1755,7 @@ def explain_memory(target: Path, identifier: str, json_output: bool = False) ->
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     try:
         explanation = _memory_explanation(wiki_dir, identifier)
     except ValueError as exc:
@@ -1785,8 +1781,7 @@ def query(
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     query_text = _clean_text_input(query_text, max_len=500)
     project_name = project or _default_project(target)
     payload = _query_link(wiki_dir, query_text, budget=budget, project=project_name)
@@ -1809,8 +1804,7 @@ def graph_summary(
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     topic = _clean_text_input(topic, max_len=500)
     cache = _core_build_wiki_cache(wiki_dir)
     payload = _core_graph_summary(
@@ -1840,8 +1834,7 @@ def benchmark(
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     query_text = _clean_text_input(query_text, max_len=500)
     project_name = project or _default_project(target)
     payload = _core_build_benchmark_payload(
@@ -1870,8 +1863,7 @@ def brief(
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     query = _clean_text_input(query, max_len=500)
     project_name = project or _default_project(target)
     payload = _memory_brief(wiki_dir, query=query, limit=limit, project=project_name)
@@ -1899,8 +1891,7 @@ def start(
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     task = _clean_text_input(task, max_len=500)
     project_name = project or _default_project(target)
     status_payload = _core_link_status(wiki_dir, version=LINK_VERSION, include_validation=True)
@@ -1995,8 +1986,7 @@ def semantic(target: Path, setup: bool = False, rebuild: bool = False, json_outp
     root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     records = _memory_records(wiki_dir)
     active_count = len([
         record for record in records
@@ -2061,8 +2051,7 @@ def consolidate(target: Path, limit: int = 50, project: str | None = None, json_
     root = _resolve_link_root(target)
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     captures_payload = _core_capture_inbox(
         root,
         limit=max(1, min(limit, 50)),
@@ -2126,11 +2115,13 @@ def _hook_session_start(
         status_payload.get("content_page_count") or 0
     )
     _, brief_text = _core_render_brief_text(brief_payload, query="", project=project_name)
+    captures_payload = brief_payload.get("captures") if isinstance(brief_payload.get("captures"), dict) else {}
     _, text = _core_render_session_start_hook_text({
         "target": str(target),
         "project": project_name,
         "status": status_payload,
         "brief_text": brief_text,
+        "capture_count": int(captures_payload.get("count") or 0),
         "project_seed_recommended": project_seed_recommended,
         "backlog": brief_payload.get("backlog") or {},
     })
@@ -2220,8 +2211,7 @@ def profile(target: Path, limit: int = 10, project: str | None = None, json_outp
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     project_name = project or _default_project(target)
     profile_data = _memory_profile(wiki_dir, limit=limit, project=project_name)
 
@@ -2255,8 +2245,7 @@ def memory_audit(target: Path, limit: int = 10, project: str | None = None, json
     target = target.expanduser().resolve()
     wiki_dir = _resolve_wiki_dir(target)
     if not wiki_dir.exists():
-        print(f"Missing wiki directory: {wiki_dir}", file=sys.stderr)
-        return 1
+        return _missing_wiki_error(wiki_dir)
     payload = _memory_audit_payload(target, wiki_dir, limit=limit, project=project)
 
     if json_output:
diff --git a/mcp_package/link_core/cli_runtime.py b/mcp_package/link_core/cli_runtime.py
index 565bf1bc..d6b47543 100644
--- a/mcp_package/link_core/cli_runtime.py
+++ b/mcp_package/link_core/cli_runtime.py
@@ -535,6 +535,20 @@ def render_session_start_hook_text(payload: Mapping[str, object]) -> tuple[int,
         ])
         return 0, "\n".join(lines)
 
+    # Empty workspace: inject two useful lines, not a skeleton of zeros.
+    if (
+        not int(status.get("active_memory_count") or 0)
+        and not int(status.get("content_page_count") or 0)
+        and not int(payload.get("capture_count") or 0)
+    ):
+        lines[0] += " — empty workspace, nothing to recall yet."
+        lines.extend([
+            "To give day-one recall real project context, seed allowlisted repo docs: "
+            f"{display_command(['lnk', 'seed', '.', target])} (source-backed, no durable memory).",
+            "Save durable memory only after the user explicitly approves it.",
+        ])
+        return 0, "\n".join(lines)
+
     brief_text = str(payload.get("brief_text") or "").strip()
     if brief_text:
         lines.extend(["", brief_text])
diff --git a/tests/test_link_cli.py b/tests/test_link_cli.py
index 4695432a..dbf307d7 100644
--- a/tests/test_link_cli.py
+++ b/tests/test_link_cli.py
@@ -2795,6 +2795,34 @@ def test_hook_session_start_prints_memory_brief(self):
         self.assertIn("Relevant memories", text)
         self.assertIn("Save durable memory only after explicit user approval.", text)
 
+    def test_hook_session_start_empty_workspace_is_compact(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+        target = tmp / "empty"
+        with redirect_stdout(StringIO()):
+            link_cli.init_wiki(target)
+
+        out = StringIO()
+        with patch("sys.stdin", self._hook_stdin({"cwd": str(tmp)})):
+            with redirect_stdout(out):
+                code = link_cli.run_agent_hook(target, "session-start")
+
+        self.assertEqual(code, 0)
+        text = out.getvalue()
+        self.assertIn("empty workspace, nothing to recall yet", text)
+        self.assertNotIn("Relevant memories", text)
+        self.assertLess(len(text.splitlines()), 6)
+
+    def test_missing_wiki_error_points_to_next_step(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
+
+        err = StringIO()
+        with redirect_stderr(err):
+            code = link_cli.recall(tmp / "nowhere", "anything")
+
+        self.assertEqual(code, 1)
+        self.assertIn("Missing wiki directory", err.getvalue())
+        self.assertIn("init", err.getvalue())
+
     def test_hook_session_start_missing_wiki_exits_zero_with_guidance(self):
         tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
         target = tmp / "missing"

From 7ee58533ddc438e6477cf82fd014a5c8d8f724a6 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 08:19:55 -0600
Subject: [PATCH 08/25] Update Pages site and README with the new feature story
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- getting-started.html: new steps 9 (session hooks: one command makes the
  memory loop automatic) and 10 (optional hybrid semantic recall with both
  tiers and MCP-only setup), onboard --hooks example, ToC entries.
- mcp.html: semantic extras + --semantic-setup in the MCP-only install,
  offline-loading guarantee, hooks-installed workflow note, and the
  review consolidate action.
- security.html: privacy bullets for offline-only semantic models, plain
  JSON embeddings, and proposal-only hook capture.
- Landing page: design-principle cards updated — hooks-injected shared
  memory, and 'No services, no APIs' reworded for the optional local
  semantic tier measured in the open.
- README now reads as a product doc: new 'Why Link Is Different' section
  (four architectural commitments + measured-not-asserted with benchmark
  links) placed before Quick Start; recall/review tool bullets cover
  match labels and consolidate; privacy section covers semantic offline
  loading and proposal-only hooks.
---
 README.md                 | 37 ++++++++++++++++++++++++++++++++++---
 docs/getting-started.html | 19 ++++++++++++++++++-
 docs/index.html           |  2 +-
 docs/mcp.html             |  7 ++++++-
 docs/security.html        |  2 ++
 5 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index add06126..eed0d587 100644
--- a/README.md
+++ b/README.md
@@ -73,6 +73,29 @@ Link follows Andrej Karpathy's
 keep knowledge outside the chat window, make claims inspectable, and let context
 compound over time.
 
+## Why Link Is Different
+
+Every other agent-memory system stores memory as embeddings in a vector
+database or as an LLM-extracted graph. Link made four architectural
+commitments those designs cannot bolt on:
+
+1. **Memory you can read.** Every memory is a plain Markdown file — open it,
+   grep it, git-diff it. If Link disappeared tomorrow, your memory is still yours.
+2. **Review-gated writes.** Agents propose; you approve. Even the automatic
+   session hooks capture proposals, never facts.
+3. **No LLM in the memory layer.** Ingestion and recall are deterministic —
+   nothing can hallucinate a fact into your memory, because there is no model
+   in the write path.
+4. **Provably local.** CI blocks outbound network code in the runtime, and the
+   optional semantic models load offline-only after one explicit setup.
+
+And the claims are measured, not asserted: a reproducible 1,176-case recall
+benchmark plus a third-party LoCoMo retrieval track, with published miss rates
+and a CI gate against regressions —
+[benchmarks/RESULTS.md](benchmarks/RESULTS.md). Named comparisons against
+Mem0/OpenMemory, Zep/Graphiti, and Letta:
+[Why Link?](https://gowtham0992.github.io/link/why-link.html)
+
 ## Quick Start
 
 Start with the memory proof. It creates a clean local workspace, writes one
@@ -445,15 +468,18 @@ model-facing tools. CLI and skill workflows call the same core behavior through
   next actions.
 - `recall`: the one read path for startup briefs, answer-ready query packets,
   wiki search, graph context, token budgets, and follow-up actions. Every
-  recalled memory carries a `confidence` label (`strong`, `moderate`, `weak`),
-  so agents verify weak lexical matches with the user instead of trusting them.
+  recalled memory carries a `confidence` label (`strong`, `moderate`, `weak`)
+  and a `match` field (`lexical`, `semantic`, `hybrid` when the optional local
+  semantic tier is installed), so agents verify weak or paraphrase matches with
+  the user instead of trusting them.
 - `remember`: durable local memory only after explicit user approval, with
   duplicate/conflict checks, provenance, review state, visibility, optional
   `review_after`, and optional `expires_at`.
 - `ingest`: exact next steps for raw files, source safety, stale ingest
   detection, validation, and rebuild checks.
 - `review`: memory inbox, profile, audit, log, explain, archive, restore,
-  forget, and lifecycle review workflows.
+  forget, and lifecycle review workflows — plus `review(action="consolidate")`,
+  a read-only backlog plan applied only with per-action user approval.
 - `admin`: the escape hatch for backup, migrate, validate, graph export, pages,
   captures, rebuilds, compatibility actions, and advanced updates.
 
@@ -553,6 +579,11 @@ Link itself is local-first:
   checks. `lnk validate` and `lnk doctor` also fail if secret-looking values
   are found inside wiki pages before they can be served through the local UI or
   returned through agent context.
+- Optional semantic recall stays local: models load offline-only at recall
+  time (only the explicit `lnk semantic --setup` may fetch a model, once), and
+  embeddings live in plain JSON under `.link-cache/`.
+- Automatic session hooks store proposal-only notes; transcript extraction
+  skips tool calls and outputs, and no durable memory is written without review.
 - The local web server binds to `127.0.0.1` and is not meant to be exposed to
   the internet without additional auth.
 
diff --git a/docs/getting-started.html b/docs/getting-started.html
index e685f0ff..44827430 100644
--- a/docs/getting-started.html
+++ b/docs/getting-started.html
@@ -55,6 +55,8 @@ <h1>Prove that your agent can remember.</h1>
         <a href="#memory">Save one memory</a>
         <a href="#ingest">Ask the agent to ingest</a>
         <a href="#verify">Verify the loop</a>
+        <a href="#hooks">Make it automatic</a>
+        <a href="#semantic">Semantic recall</a>
       </aside>
       <article class="doc-content">
         <h2 id="demo">1. Prove The Memory Loop</h2>
@@ -104,7 +106,8 @@ <h2 id="onboard">2. Onboard A Real Workspace</h2>
 lnk onboard --first-memory "I prefer concise release notes"
 lnk onboard --seed-project .
 lnk onboard --agent codex
-lnk onboard --agent codex --write</code></pre>
+lnk onboard --agent codex --write
+lnk onboard --agent claude-code --hooks --write</code></pre>
         <p>From source, use <code>python3 link.py onboard</code> on macOS/Linux or <code>py link.py onboard</code> on Windows. The command is safe to re-run: it preserves existing wiki data and only applies safe structural repairs. Add <code>--seed-project .</code> from inside a repo when you want onboarding to create the first source-backed project page. If the local viewer is running, <code>http://127.0.0.1:3000/onboard</code> shows the same setup loop with copy buttons.</p>
 
         <h2 id="seed">3. Seed Project Context</h2>
@@ -190,6 +193,20 @@ <h2 id="verify">8. Verify The Loop</h2>
         <p><code>lnk verify-mcp</code> should report <code>Result: ready</code> when you use MCP. Then ask your agent:</p>
         <pre><code>query Link for first Link memory</code></pre>
         <p>If the answer comes from Link, local agent memory is working.</p>
+              <h2 id="hooks">9. Make The Loop Automatic (Session Hooks)</h2>
+        <p>Agents with session-hook support — Claude Code, Codex, and Cursor — can run the memory loop without being asked. <code>--hooks</code> installs hooks that inject a bounded memory brief at the start of every new session and store proposal-only session notes at session end. Empty sessions are skipped, duplicate end events are deduplicated, and durable memory still requires your approval. When the review backlog grows, the injected brief nudges the agent to offer a read-only <code>lnk consolidate</code> pass.</p>
+        <pre><code>lnk connect claude-code ~/link --hooks --write
+lnk connect codex ~/link --hooks --write    # session-start brief (Codex has no session-end event)
+lnk connect cursor ~/link --hooks --write</code></pre>
+        <p>Codex and Cursor hook support is new and follows those vendors' documented hook schemas; if a hook misbehaves there, please open an issue.</p>
+
+        <h2 id="semantic">10. Optional: Hybrid Semantic Recall</h2>
+        <p>Lexical recall is always the default and the fallback. Two optional local tiers add paraphrase recall — "how should I structure my pull requests" finds a memory about commit style. The models load offline-only at recall time (a query can never trigger a download), embeddings are plain JSON under <code>.link-cache/</code>, and there is no vector database or service.</p>
+        <pre><code>pip install "link-mcp[semantic]"          # fast tier: tiny static model, instant load
+pip install "link-mcp[semantic-quality]"  # quality tier: contextual model, best recall
+lnk semantic ~/link --setup               # explicit one-time model fetch
+python3 -m link_mcp --semantic-setup --wiki ~/link/wiki   # MCP-only installs</code></pre>
+        <p>Recall quality is measured, not asserted: see <a href="https://github.com/gowtham0992/link/blob/main/benchmarks/RESULTS.md">benchmarks/RESULTS.md</a> for the full methodology, numbers, and honest limitations.</p>
       </article>
     </div>
   </main>
diff --git a/docs/index.html b/docs/index.html
index 561c886f..ff99d031 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -184,7 +184,7 @@
   </script>
 
   <script type="__bundler/template">
-"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Most agent sessions start from zero. Link turns your notes, transcripts, and docs into an inspectable Markdown wiki — and explicit “remember this” requests into reviewable, source-backed memory that stays on your machine and works across every agent.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no embeddings<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share, instead of context trapped inside a single chat.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No external dependencies', desc: 'Pure Python. No vector databases, no embedding APIs, no npm.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
+"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Most agent sessions start from zero. Link turns your notes, transcripts, and docs into an inspectable Markdown wiki — and explicit “remember this” requests into reviewable, source-backed memory that stays on your machine and works across every agent.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no embeddings<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
   </script>
 <script>(function(){var T='Link \u2014 Local memory for AI agents',I='assets/favicon.svg';function e(){if(document.title!==T)document.title=T;if(!document.querySelector('link[rel=\"icon\"]')){var l=document.createElement('link');l.rel='icon';l.type='image/svg+xml';l.href=I;document.head.appendChild(l);}}e();document.addEventListener('DOMContentLoaded',e);window.addEventListener('load',function(){e();setTimeout(e,300);setTimeout(e,1200);});try{new MutationObserver(e).observe(document.head,{childList:true});}catch(_){}})();</script>
 </body>
diff --git a/docs/mcp.html b/docs/mcp.html
index f8d78ca8..fcb279ed 100644
--- a/docs/mcp.html
+++ b/docs/mcp.html
@@ -103,7 +103,11 @@ <h2 id="installers">Agent Installers</h2>
 
         <h2 id="mcp-only">MCP Only</h2>
         <pre><code>python3 -m pip install --upgrade link-mcp
-python3 -m link_mcp --version</code></pre>
+python3 -m link_mcp --version
+# optional local semantic recall (fast or quality tier):
+python3 -m pip install "link-mcp[semantic-quality]"
+python3 -m link_mcp --semantic-setup --wiki ~/link/wiki</code></pre>
+        <p>The semantic extras stay fully local: the embedding model is fetched once by the explicit <code>--semantic-setup</code> command, and the serving path loads it offline-only — a recall can never download anything.</p>
         <pre><code>{
   "mcpServers": {
     "link": {
@@ -128,6 +132,7 @@ <h2 id="mcp-only">MCP Only</h2>
 }</code></pre>
 
         <h2 id="workflow">Predictable Agent Workflow</h2>
+        <p>If Link session hooks are installed for the agent (<code>lnk connect &lt;agent&gt; --hooks --write</code>), the startup brief is injected automatically — agents should skip the manual brief call and go straight to bounded task recall. When a brief reports a memory backlog, <code>review(action="consolidate")</code> returns a read-only consolidation plan to walk through with the user.</p>
         <p>New MCP configs use the slim surface by default so agents see one obvious read tool and one obvious write tool instead of a long menu of overlapping helpers. The full compatibility surface remains available with <code>--surface full</code>.</p>
         <p>Slim agents should use Link in this order:</p>
         <ol>
diff --git a/docs/security.html b/docs/security.html
index ac3c56bc..d3c74cae 100644
--- a/docs/security.html
+++ b/docs/security.html
@@ -63,6 +63,8 @@ <h2 id="privacy">Privacy Model</h2>
           <li>No external API calls from <code>serve.py</code> or <code>link-mcp</code>.</li>
           <li>Raw sources and generated wiki pages are ignored by git by default.</li>
           <li>SQLite search, when available, is an in-memory derived index. Markdown remains the source of truth.</li>
+          <li>Optional semantic recall stays local: embedding models load offline-only at recall time (only the explicit <code>lnk semantic --setup</code> may fetch a model, once), embeddings live in plain JSON under <code>.link-cache/</code>, and CI blocks outbound network code in the runtime.</li>
+          <li>Automatic session hooks store proposal-only notes; no durable memory is written without explicit review, and transcript extraction skips tool calls and tool outputs.</li>
         </ul>
         <p>The public GitHub Pages documentation may use lightweight analytics to understand install interest. It does not run inside Link, read local wiki data, or capture source/memory content.</p>
 

From a19fe899971df531efb2cd3d5960ce02497e1d8a Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 10:58:06 -0600
Subject: [PATCH 09/25] Record two rejected recall ablations: static MaxSim and
 PMI query expansion

Both candidate mechanisms measured worse than or equal to the shipped
approach on the recall benchmark; documented so the methodology shows
its negative results.
---
 benchmarks/RESULTS.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/benchmarks/RESULTS.md b/benchmarks/RESULTS.md
index b3919daa..e700337e 100644
--- a/benchmarks/RESULTS.md
+++ b/benchmarks/RESULTS.md
@@ -71,6 +71,13 @@ Full suite, Apple M4, macOS 26.5.1, Python 3.14, run 2026-07-08, Link
   The zero-overlap ceiling is the static-embedding paradigm itself, which is
   why the quality tier uses a contextual model instead of a bigger static one.
 - **potion-base-32M**: marginal over 8M; not worth 4× the size as a default.
+- **Token-level late interaction (MaxSim over static token vectors)**: worse
+  than blob embeddings on both groups (zero-overlap hit@5 0.160 vs 0.202) —
+  static per-token vectors are too noisy for ColBERT-style matching.
+- **Corpus-mined PMI query expansion** (learning the user's vocabulary from
+  their own wiki): cannot help zero-overlap queries by construction (there is
+  no shared token to expand from) and slightly hurt token-overlap hit@1 by
+  pulling in competing memories. Rejected.
 
 ## Track 2: LoCoMo third-party retrieval
 

From 4e0c8fe74107627f4f4c76144e2ddd0c3aefc94d Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 14:03:41 -0600
Subject: [PATCH 10/25] Complete 1.6 coverage in shipped skills and second-tier
 docs pages

A full editorial audit before the 1.6.0 cut found the flagship features
documented on the primary surfaces (README, landing, getting-started,
CLI, MCP, why, security) but absent from the surfaces skill-first agents
and troubleshooting users actually read:

- Official skills: link-memory teaches the hooks-installed rule (skip
  the manual brief) and the read-only consolidation pass; link-retrieve
  teaches confidence + match labels (verify semantic/weak matches);
  link-health adds the lnk semantic status check.
- memory-contract.html: the hooked loop, honest recall signals, and the
  consolidate action are now part of the documented contract.
- concepts.html: hybrid two-tier retrieval and the automatic lifecycle
  (automation changes when memory is proposed, never who decides).
- skills.html: the two new agent rules.
- troubleshooting.html: 'Session Hooks Are Not Firing' (including
  hook session-end --explain) and 'Semantic Recall Is Not Working'
  (wrong-interpreter, setup, kill-switch causes).
- scale.html: links the measured recall benchmarks.
---
 CHANGELOG.md                  | 2 ++
 docs/concepts.html            | 2 ++
 docs/memory-contract.html     | 3 +++
 docs/scale.html               | 1 +
 docs/skills.html              | 1 +
 docs/troubleshooting.html     | 9 +++++++++
 skills/link-health/SKILL.md   | 6 ++++++
 skills/link-memory/SKILL.md   | 8 ++++++++
 skills/link-retrieve/SKILL.md | 2 ++
 9 files changed, 34 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 00fca53b..bac8d7d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,8 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 
 ## [Unreleased]
 
+- Completed 1.6 coverage across the second-tier docs and shipped skills: the official CLI skills now teach the hooks-installed rule, the consolidation pass, semantic match labels, and the `lnk semantic` status check; the memory contract documents the hooked loop and honest recall signals; concepts covers hybrid retrieval and the automatic lifecycle; troubleshooting gains "hooks not firing" and "semantic recall not working" sections; and the scale page links the measured benchmarks.
+
 ### Added
 
 - Added `lnk connect <agent> --hooks` to install agent session hooks alongside MCP config for Claude Code, Codex, and Cursor: every new session starts with a bounded Link memory brief injected automatically, and session end stores proposal-only session notes with memory candidates, so the memory loop no longer depends on the agent remembering to call Link. Codex has no session-end hook event, so it gets the session-start brief only; Cursor uses its flat `hooks.json` schema and JSON `additional_context` envelope.
diff --git a/docs/concepts.html b/docs/concepts.html
index 98002034..dd1a66fc 100644
--- a/docs/concepts.html
+++ b/docs/concepts.html
@@ -87,6 +87,7 @@ <h2 id="moves">Three User Moves</h2>
         <p>Raw files do not silently personalize future agents. Ingest creates source-backed wiki knowledge. Explicit <code>remember</code> creates durable user or project memory.</p>
 
         <h2 id="memory">Memory Lifecycle</h2>
+        <p>The lifecycle can run automatically: session hooks inject the memory brief at session start and store proposal-only notes at session end, and when the review backlog grows, briefs nudge the agent to offer a read-only <code>lnk consolidate</code> pass. Every write still requires explicit user approval — automation changes when memory is <em>proposed</em>, never who decides.</p>
         <p>A memory is a Markdown page with status, scope, visibility, source, review state, optional <code>review_after</code> and <code>expires_at</code> dates, graph links, and local log entries. It can be proposed, remembered, reviewed, updated, archived, restored, explained, or forgotten.</p>
         <div class="grid">
           <article class="feature"><h3>Propose</h3><p>Generate candidate memories from chat notes or raw captures without writing durable memory.</p></article>
@@ -97,6 +98,7 @@ <h2 id="memory">Memory Lifecycle</h2>
         </div>
 
         <h2 id="query">Smart Query Packets</h2>
+        <p>Retrieval is lexical by default (token matching, stemming, SQLite FTS) and optionally <em>hybrid</em>: two local embedding tiers (a tiny static model for instant CLI use, a contextual model for the MCP server) add paraphrase recall while staying fully offline at query time. Semantic matches are labeled and confidence-capped so agents verify before trusting them; measured results live in <a href="https://github.com/gowtham0992/link/blob/main/benchmarks/RESULTS.md">benchmarks/RESULTS.md</a>.</p>
         <p><code>recall</code> is designed for agents. It returns a compact packet with a <code>recall_capsule</code>, relevant memory, ranked wiki pages, graph context, provenance, budget reports, estimated size, and follow-up actions.</p>
         <p>Budget tiers keep context predictable:</p>
         <ul>
diff --git a/docs/memory-contract.html b/docs/memory-contract.html
index 2e5b1ddb..27f2fc93 100644
--- a/docs/memory-contract.html
+++ b/docs/memory-contract.html
@@ -65,6 +65,7 @@ <h2 id="promise">Contract Promise</h2>
         </div>
 
         <h2 id="loop">Recommended Agent Loop</h2>
+        <p><strong>With session hooks installed</strong> (<code>lnk connect &lt;agent&gt; --hooks --write</code>), step one happens automatically: the bounded memory brief is injected at session start and proposal-only notes are captured at session end. Hooked agents skip the manual brief call and go straight to bounded task recall.</p>
         <ol>
           <li>Call <code>status</code>. If schema or validation needs attention, follow the safe action it returns.</li>
           <li>Call <code>recall</code> with an empty query once at the first substantive turn of a session.</li>
@@ -95,6 +96,8 @@ <h2 id="tools">Core Tool Groups</h2>
           </tbody>
         </table>
 
+        <p>Recalled memories carry honest signals agents must respect: a <code>confidence</code> label (<code>strong</code>/<code>moderate</code>/<code>weak</code>) and, when the optional local semantic tier is installed, a <code>match</code> field (<code>lexical</code>/<code>hybrid</code>/<code>semantic</code>). Semantic-only matches are capped below strong confidence — verify them with the user before acting. When a brief reports a memory backlog, <code>review(action="consolidate")</code> (or <code>lnk consolidate</code>) returns a read-only plan; apply its actions only with per-item user approval.</p>
+
         <h2 id="writes">Write Rules</h2>
         <p>Agents should treat Link memory as durable state, not scratch space.</p>
         <ul>
diff --git a/docs/scale.html b/docs/scale.html
index 4251f71b..91a8aefe 100644
--- a/docs/scale.html
+++ b/docs/scale.html
@@ -75,6 +75,7 @@ <h2 id="bounded">Bounded Surfaces</h2>
         </div>
 
         <h2 id="measure">Measure Locally</h2>
+        <p>Recall quality is measured too, not just speed: the repo ships a 1,176-case recall benchmark and a third-party LoCoMo retrieval track with reproduction commands — see <a href="https://github.com/gowtham0992/link/blob/main/benchmarks/RESULTS.md">benchmarks/RESULTS.md</a>.</p>
         <p>Use <code>lnk benchmark</code> on your real wiki. It reports cache time, persistent-cache reuse, search backend, search/query timing, graph payload shape, value evidence, and recommendations. The value section compares broad wiki body text with the bounded query packet so you can see whether Link is reducing context-budget waste.</p>
         <pre><code>lnk benchmark "agent memory"
 lnk health
diff --git a/docs/skills.html b/docs/skills.html
index ddbd80cb..f15433ac 100644
--- a/docs/skills.html
+++ b/docs/skills.html
@@ -91,6 +91,7 @@ <h2 id="install">Use Them</h2>
 remember that I prefer short release notes</code></pre>
 
         <h2 id="rules">Rules For Agents</h2>
+        <p>Two additions with 1.6: if Link session hooks are installed, the startup brief arrives automatically — skip the manual brief and go straight to bounded task recall. And when a brief reports a memory backlog, offer the user a read-only <code>lnk consolidate</code> pass instead of letting captures pile up.</p>
         <ul>
           <li>Prefer <code>lnk health</code> when readiness is unclear, especially after an install, upgrade, restore, or broad wiki edit.</li>
           <li>Start with <code>lnk start</code> for readiness plus memory context, and use <code>lnk session-end</code> to capture proposal-only memory candidates at the end of meaningful work.</li>
diff --git a/docs/troubleshooting.html b/docs/troubleshooting.html
index a04149f7..97dd15f6 100644
--- a/docs/troubleshooting.html
+++ b/docs/troubleshooting.html
@@ -53,6 +53,8 @@ <h1>Start with status, then repair deliberately.</h1>
         <a href="#operations">Interrupted writes</a>
         <a href="#graph">Graph is stale</a>
         <a href="#demo">Demo looks stale</a>
+        <a href="#hooks">Hooks not firing</a>
+        <a href="#semantic">Semantic recall</a>
         <a href="#slow">The wiki feels slow</a>
         <a href="#pip">pip is blocked</a>
       </aside>
@@ -94,6 +96,13 @@ <h2 id="demo">Demo Looks Stale</h2>
 python3 link.py query "why does Link help agents?" link-demo --budget small</code></pre>
         <p>The current generated demo should include three raw sources, source-backed wiki pages, four starter memories (three reviewed, one pending review), one exploration, current backlinks, and schema v1.</p>
 
+        <h2 id="hooks">Session Hooks Are Not Firing</h2>
+        <p>Check the agent's settings file (for Claude Code, <code>~/.claude/settings.json</code>) for the Link entries under <code>SessionStart</code>/<code>SessionEnd</code>; rerunning <code>lnk connect &lt;agent&gt; --hooks --write</code> is idempotent and repairs a workspace runtime that predates hooks. If sessions start with the brief but nothing is captured at session end, that is usually correct behavior — trivial sessions, duplicates, and restatements of existing memory are skipped by design. See exactly why with:</p>
+        <pre><code>lnk hook session-end ~/link --explain</code></pre>
+
+        <h2 id="semantic">Semantic Recall Is Not Working</h2>
+        <p><code>lnk semantic ~/link</code> shows the active provider and tier. Common causes: the extra was installed into a different Python than the one running Link (the status output names the interpreter it checked, and the error prints the exact venv-side command such as <code>python3 -m link_mcp --semantic-setup</code>); the one-time model fetch has not run (<code>lnk semantic ~/link --setup</code>); or <code>LINK_SEMANTIC=off</code> is set. Recall itself never downloads anything — a missing model degrades silently to lexical recall by design.</p>
+
         <h2 id="slow">The Wiki Feels Slow</h2>
         <pre><code>lnk benchmark "agent memory"
 lnk graph-summary "agent memory" --limit 40 --depth 1</code></pre>
diff --git a/skills/link-health/SKILL.md b/skills/link-health/SKILL.md
index 2bfb25b1..ba0bddef 100644
--- a/skills/link-health/SKILL.md
+++ b/skills/link-health/SKILL.md
@@ -32,3 +32,9 @@ Use the `lnk` CLI. Load this skill before trusting a new or changed Link wiki, a
    ```
 
 If the user asks whether MCP is ready, run `lnk verify-mcp [link-root]`. Do not start `lnk serve` for MCP or CLI work.
+
+To check whether optional local semantic recall is active (lexical is always the fallback):
+```bash
+lnk semantic [link-root]
+```
+It reports the provider tier, model, and index state, and prints the exact setup command when the layer is available but not yet enabled.
diff --git a/skills/link-memory/SKILL.md b/skills/link-memory/SKILL.md
index 93a13e59..d2b37924 100644
--- a/skills/link-memory/SKILL.md
+++ b/skills/link-memory/SKILL.md
@@ -7,6 +7,8 @@ description: Use after important user-approved decisions, when durable context s
 
 Use this skill after important user-approved decisions, preference changes, project conventions, or long work sessions that may deserve durable context. In a source checkout, replace `lnk` with `python3 link.py`. Do not silently save durable memory; propose first unless the user directly asks to remember, approves a proposal, or explicitly confirms an important decision should become durable memory.
 
+If Link session hooks are installed for this agent, the memory brief is injected automatically at session start — skip step 1 and go straight to task-specific recall.
+
 1. Prime before work:
    ```bash
    lnk brief "<current task>" [link-root]
@@ -25,6 +27,12 @@ Use this skill after important user-approved decisions, preference changes, proj
    lnk remember "<user-approved memory>" [link-root] --type note --scope user
    ```
    Use `--project <slug>` for project-scoped memory, `--visibility private|project|team` for sharing intent, `--review-after YYYY-MM-DD` for stale-risk memories, and `--expires-at YYYY-MM-DD` for temporary context.
+When a brief or recall reports a memory backlog (pending captures or reviews above threshold), offer the user a short consolidation pass:
+   ```bash
+   lnk consolidate [link-root]
+   ```
+   The plan is read-only: it groups duplicates and recurring themes and prints accept/discard/review commands. Apply an action only after the user approves it.
+
 5. Review and explain before trusting uncertain memory:
    ```bash
    lnk memory-inbox [link-root]
diff --git a/skills/link-retrieve/SKILL.md b/skills/link-retrieve/SKILL.md
index 85a52123..003627ed 100644
--- a/skills/link-retrieve/SKILL.md
+++ b/skills/link-retrieve/SKILL.md
@@ -35,3 +35,5 @@ Use bounded CLI commands so the agent does not dump the whole wiki into context.
    ```
 
 Do not enumerate every page, grep raw files, or request the full graph unless the user explicitly asks for an export or exhaustive audit, or the compact packet is insufficient and tells you which follow-up to use.
+
+Recalled memories carry `confidence` labels and, when the optional local semantic tier is installed, a `match` field: `lexical`, `hybrid`, or `semantic`. Treat `semantic` matches (paraphrase similarity, capped confidence) and `weak` matches as hints to verify with the user, not facts to act on.

From 792464e0cd2a5fb263ea7e4a6dc311a34c299939 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 14:45:14 -0600
Subject: [PATCH 11/25] Fix stale landing footer tagline for the optional
 semantic tier

'no embeddings' became imprecise once optional local embedding tiers
shipped; the footer now says 'no services', matching the design
principle card. Also ignore local .claude/ tooling configs.
---
 .gitignore      | 3 +++
 docs/index.html | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index a3c72310..f20faf58 100644
--- a/.gitignore
+++ b/.gitignore
@@ -78,3 +78,6 @@ id_rsa
 id_ed25519
 # Local design references
 Link Console Handoff.html
+
+# Local editor/agent tooling
+.claude/
diff --git a/docs/index.html b/docs/index.html
index ff99d031..46ae4d3b 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -184,7 +184,7 @@
   </script>
 
   <script type="__bundler/template">
-"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Most agent sessions start from zero. Link turns your notes, transcripts, and docs into an inspectable Markdown wiki — and explicit “remember this” requests into reviewable, source-backed memory that stays on your machine and works across every agent.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no embeddings<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
+"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Most agent sessions start from zero. Link turns your notes, transcripts, and docs into an inspectable Markdown wiki — and explicit “remember this” requests into reviewable, source-backed memory that stays on your machine and works across every agent.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
   </script>
 <script>(function(){var T='Link \u2014 Local memory for AI agents',I='assets/favicon.svg';function e(){if(document.title!==T)document.title=T;if(!document.querySelector('link[rel=\"icon\"]')){var l=document.createElement('link');l.rel='icon';l.type='image/svg+xml';l.href=I;document.head.appendChild(l);}}e();document.addEventListener('DOMContentLoaded',e);window.addEventListener('load',function(){e();setTimeout(e,300);setTimeout(e,1200);});try{new MutationObserver(e).observe(document.head,{childList:true});}catch(_){}})();</script>
 </body>

From 76d3ae83fc3327ecd78bd7a0d364bdfe097aefb7 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 15:05:23 -0600
Subject: [PATCH 12/25] Lead the landing hero with the 1.6 story: automatic,
 review-gated, measured

The flagship features existed on the home page only as card fine print;
the hero and meta description still told the pre-1.6 story. A skimming
visitor never learned the two headline facts. The hero paragraph and
meta description now lead with them: memory injected automatically at
session start, proposals at session end with every save approved by the
user, and hybrid local recall measured in the open.
---
 docs/index.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/index.html b/docs/index.html
index 46ae4d3b..e1c03fbc 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8">
   <title>Link — Local memory for AI agents</title>
-  <meta name="description" content="Link is local, source-backed memory for AI agents. Raw notes become an inspectable Markdown wiki; explicit \"remember this\" requests become reviewable memory. Stored locally, shared across Codex, Claude, Cursor, Kiro, and more.">
+  <meta name="description" content="Link is local, source-backed memory for AI agents — injected automatically at session start, review-gated on every save, with hybrid recall measured in the open. Plain Markdown, no cloud, shared across Claude Code, Codex, Cursor, and more."remember this\" requests become reviewable memory. Stored locally, shared across Codex, Claude, Cursor, Kiro, and more.">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="theme-color" content="#faf9f5">
   <link rel="canonical" href="https://gowtham0992.github.io/link/">
@@ -184,7 +184,7 @@
   </script>
 
   <script type="__bundler/template">
-"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Most agent sessions start from zero. Link turns your notes, transcripts, and docs into an inspectable Markdown wiki — and explicit “remember this” requests into reviewable, source-backed memory that stays on your machine and works across every agent.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
+"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Agent sessions no longer start from zero: Link injects your memory automatically when a session begins, and proposes new memory when it ends — you approve every save. Notes and docs become an inspectable Markdown wiki; recall is hybrid, local, and measured in the open. One memory, every agent, your machine.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
   </script>
 <script>(function(){var T='Link \u2014 Local memory for AI agents',I='assets/favicon.svg';function e(){if(document.title!==T)document.title=T;if(!document.querySelector('link[rel=\"icon\"]')){var l=document.createElement('link');l.rel='icon';l.type='image/svg+xml';l.href=I;document.head.appendChild(l);}}e();document.addEventListener('DOMContentLoaded',e);window.addEventListener('load',function(){e();setTimeout(e,300);setTimeout(e,1200);});try{new MutationObserver(e).observe(document.head,{childList:true});}catch(_){}})();</script>
 </body>

From 5f3f0c185597f3cb0d32453b867a5c099b266b0f Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 15:07:39 -0600
Subject: [PATCH 13/25] Restore 'source-backed' to the landing hero

The 1.6 hero rewrite kept four of the five founding claims (inspectable
wiki, review-gated saves, local, cross-agent) but dropped the provenance
word. Source-backed memory is a load-bearing differentiator, not
decoration; it belongs in the first paragraph a visitor reads.
---
 docs/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/index.html b/docs/index.html
index e1c03fbc..0e86d799 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -184,7 +184,7 @@
   </script>
 
   <script type="__bundler/template">
-"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Agent sessions no longer start from zero: Link injects your memory automatically when a session begins, and proposes new memory when it ends — you approve every save. Notes and docs become an inspectable Markdown wiki; recall is hybrid, local, and measured in the open. One memory, every agent, your machine.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
+"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Agent sessions no longer start from zero: Link injects your memory automatically when a session begins, and proposes new memory when it ends — you approve every save. Notes and docs become an inspectable, source-backed Markdown wiki; recall is hybrid, local, and measured in the open. One memory, every agent, your machine.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
   </script>
 <script>(function(){var T='Link \u2014 Local memory for AI agents',I='assets/favicon.svg';function e(){if(document.title!==T)document.title=T;if(!document.querySelector('link[rel=\"icon\"]')){var l=document.createElement('link');l.rel='icon';l.type='image/svg+xml';l.href=I;document.head.appendChild(l);}}e();document.addEventListener('DOMContentLoaded',e);window.addEventListener('load',function(){e();setTimeout(e,300);setTimeout(e,1200);});try{new MutationObserver(e).observe(document.head,{childList:true});}catch(_){}})();</script>
 </body>

From 55b2d9316d4e0794aff4a74e2c2ea1c73e2776cb Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 15:10:34 -0600
Subject: [PATCH 14/25] Guard the founding identity claims in landing and
 README
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Every release pulls attention toward its newest features; three releases
from now the site could read like a benchmark product with the founding
story reduced to a footnote. This test encodes the claims that made Link
through 1.5.0 — source-backed provenance, inspectable Markdown,
review-gated writes, local-first, cross-agent, the proof loop — and
fails any landing or README rewrite that drops one, so forgetting
becomes a deliberate decision instead of an accident.
---
 tests/test_docs_site.py | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/tests/test_docs_site.py b/tests/test_docs_site.py
index 66d96b48..d0869dff 100644
--- a/tests/test_docs_site.py
+++ b/tests/test_docs_site.py
@@ -118,3 +118,37 @@ def test_github_pages_analytics_is_docs_only_and_manual(self):
 
 if __name__ == "__main__":
     unittest.main()
+
+class FoundingIdentityTests(unittest.TestCase):
+    """New releases layer onto Link's founding story; they must never bury it.
+
+    These are the identity claims that made Link through 1.5.0. If a landing
+    or README rewrite drops one, this test fails and the author must decide
+    deliberately — not by accident of enthusiasm for the newest feature.
+    """
+
+    PILLARS = {
+        "source-backed": "provenance: memory that can say why it is known",
+        "Markdown": "inspectable plain-file storage",
+        "approve": "review-gated writes: agents propose, the user decides",
+        "your machine": "local-first: no hosted profile",
+        "every agent": "one memory shared across agents",
+        "proof": "the first-run proof loop (lnk proof)",
+    }
+
+    def test_landing_keeps_the_founding_claims(self):
+        text = (ROOT / "docs/index.html").read_text(encoding="utf-8")
+        for phrase, meaning in self.PILLARS.items():
+            self.assertIn(phrase, text, f"landing lost founding claim: {meaning}")
+
+    def test_readme_keeps_the_founding_claims(self):
+        text = (ROOT / "README.md").read_text(encoding="utf-8")
+        for phrase, meaning in self.PILLARS.items():
+            if phrase == "approve":
+                self.assertTrue(
+                    "approval" in text or "approve" in text,
+                    f"README lost founding claim: {meaning}",
+                )
+                continue
+            self.assertIn(phrase, text, f"README lost founding claim: {meaning}")
+

From c17e21a5ed0950b864c01fb2d088a4c9a9c60523 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 15:11:22 -0600
Subject: [PATCH 15/25] Normalize whitespace in the founding-identity guard

Markdown wraps lines mid-phrase; the guard now judges claims on prose,
not line breaks.
---
 tests/test_docs_site.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/test_docs_site.py b/tests/test_docs_site.py
index d0869dff..c1708ea7 100644
--- a/tests/test_docs_site.py
+++ b/tests/test_docs_site.py
@@ -136,13 +136,19 @@ class FoundingIdentityTests(unittest.TestCase):
         "proof": "the first-run proof loop (lnk proof)",
     }
 
+    @staticmethod
+    def _flat(path):
+        # Markdown and templates wrap lines; claims are judged on prose,
+        # not line breaks.
+        return " ".join((ROOT / path).read_text(encoding="utf-8").split())
+
     def test_landing_keeps_the_founding_claims(self):
-        text = (ROOT / "docs/index.html").read_text(encoding="utf-8")
+        text = self._flat("docs/index.html")
         for phrase, meaning in self.PILLARS.items():
             self.assertIn(phrase, text, f"landing lost founding claim: {meaning}")
 
     def test_readme_keeps_the_founding_claims(self):
-        text = (ROOT / "README.md").read_text(encoding="utf-8")
+        text = self._flat("README.md")
         for phrase, meaning in self.PILLARS.items():
             if phrase == "approve":
                 self.assertTrue(

From 237deb503236f3c4174eeb0066a4b2e46c0854c9 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 15:12:21 -0600
Subject: [PATCH 16/25] Accept claim phrasings in the founding-identity guard

The guard protects claims, not exact strings: the cross-agent pillar now
accepts the README's established phrasings (shared across multiple
agents, reusable by different agents) alongside the landing's literal
wording.
---
 tests/test_docs_site.py | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/tests/test_docs_site.py b/tests/test_docs_site.py
index c1708ea7..500ba094 100644
--- a/tests/test_docs_site.py
+++ b/tests/test_docs_site.py
@@ -150,11 +150,12 @@ def test_landing_keeps_the_founding_claims(self):
     def test_readme_keeps_the_founding_claims(self):
         text = self._flat("README.md")
         for phrase, meaning in self.PILLARS.items():
-            if phrase == "approve":
-                self.assertTrue(
-                    "approval" in text or "approve" in text,
-                    f"README lost founding claim: {meaning}",
-                )
-                continue
-            self.assertIn(phrase, text, f"README lost founding claim: {meaning}")
+            variants = {
+                "approve": ("approve", "approval"),
+                "every agent": ("every agent", "across multiple agents", "different agents", "across agents"),
+            }.get(phrase, (phrase,))
+            self.assertTrue(
+                any(variant in text for variant in variants),
+                f"README lost founding claim: {meaning}",
+            )
 

From 7ed8c958fcacd0fd7fd15b8d6901609227ea9a04 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 20:10:30 -0600
Subject: [PATCH 17/25] Fix first-ten-minutes friction found by walking Link
 cold as a new user

Went through the exact path a brand-new user walks (README -> proof ->
onboard -> try the pitch) and hit real walls where the two headline 1.6
features were hidden or silently off. Fixes:

P0 - flagship features were undiscoverable on the guided path:
- lnk onboard now surfaces the automatic-memory path: explains --hooks
  and prints the ready-to-run --agent <hook-capable> --hooks --write
  command; each hook-capable agent preview offers 'Make memory automatic
  (recommended)'. Before, onboard never mentioned hooks at all.
- A recall that finds nothing while memories exist now tells the user
  paraphrase matching (semantic recall) is off by default and how to
  enable it, instead of a bare 'No matching memories found'. The README
  paraphrase example is reframed as opt-in and the landing hero calls
  hybrid recall optional, so the marquee demo never reads as a broken
  default.

P1 - command identity whiplash and workspace confusion:
- Source-checkout commands now show a friendly 'python3 link.py' instead
  of the raw interpreter path (python@3.14 ...); Homebrew users still see
  plain lnk.
- lnk proof labels its workspace a throwaway demo, adds a 'what this
  means for you' line, and points to lnk onboard for real memory.

P2:
- prepare_release.py reminds maintainers to bump the Homebrew tap so
  brew install never serves an older Link than the docs describe.

Four regression tests pin the onboard-hooks and recall-miss-hint
behaviors. 819 tests + guards green.
---
 CHANGELOG.md                         |  7 ++++
 README.md                            | 10 +++--
 docs/index.html                      |  2 +-
 link.py                              | 44 ++++++++++++++++++++-
 mcp_package/link_core/cli_memory.py  |  5 ++-
 mcp_package/link_core/cli_runtime.py | 13 +++++-
 scripts/prepare_release.py           |  6 +++
 tests/test_cli_runtime_core.py       |  3 +-
 tests/test_link_cli.py               | 59 ++++++++++++++++++++++++++++
 9 files changed, 140 insertions(+), 9 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bac8d7d4..8446f1dd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,13 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 
 ## [Unreleased]
 
+- Fixed first-ten-minutes friction found by walking Link cold as a brand-new user:
+  - `lnk onboard` now surfaces the automatic-memory path: it explains `--hooks` and prints the ready-to-run `--agent <hook-capable> --hooks --write` command, and each hook-capable agent preview offers "Make memory automatic (recommended)". Previously the flagship 1.6 feature was invisible in the guided setup.
+  - A recall that finds nothing while memories exist now tells the user paraphrase matching (semantic recall) is off by default and how to turn it on, instead of a bare "No matching memories found". The README's paraphrase example is reframed as opt-in so it never reads like a broken default, and the landing hero calls hybrid recall optional.
+  - Generated commands in source-checkout mode use a friendly `python3 link.py` instead of the raw interpreter path (e.g. `python@3.14`); Homebrew users still see plain `lnk`.
+  - `lnk proof` now says its workspace is a throwaway demo and points to `lnk onboard` for real memory, with a plain "what this means for you" line.
+  - `scripts/prepare_release.py` reminds maintainers to bump the Homebrew tap so `brew install` never serves an older Link than the docs describe.
+
 - Completed 1.6 coverage across the second-tier docs and shipped skills: the official CLI skills now teach the hooks-installed rule, the consolidation pass, semantic match labels, and the `lnk semantic` status check; the memory contract documents the hooked loop and honest recall signals; concepts covers hybrid retrieval and the automatic lifecycle; troubleshooting gains "hooks not firing" and "semantic recall not working" sections; and the scale page links the measured benchmarks.
 
 ### Added
diff --git a/README.md b/README.md
index eed0d587..f4d6739f 100644
--- a/README.md
+++ b/README.md
@@ -362,10 +362,12 @@ lnk consolidate ~/link                      # read-only backlog plan, apply only
 
 ### Optional: hybrid semantic recall (still fully local)
 
-Lexical recall is always the default and the fallback. Installing the optional
-semantic extra adds a small local static-embedding model so paraphrased
-queries also find memories phrased differently — "how should I structure my
-pull requests" finds a memory about commit style. Recall never touches the
+Lexical recall is always the default and the fallback. Paraphrase matching is
+opt-in: after the two setup commands below, "how should I structure my pull
+requests" finds a memory saved about commit style. Until then, recall matches
+on shared words, and a miss tells you how to turn paraphrase matching on.
+Installing the optional semantic extra adds a small local static-embedding
+model. Recall never touches the
 network: the model loads offline-only after a one-time explicit setup,
 embeddings live in plain JSON under `.link-cache/`, similarity runs in-process
 with no vector database, and semantic-only matches carry capped confidence
diff --git a/docs/index.html b/docs/index.html
index 0e86d799..e740cf53 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -184,7 +184,7 @@
   </script>
 
   <script type="__bundler/template">
-"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Agent sessions no longer start from zero: Link injects your memory automatically when a session begins, and proposes new memory when it ends — you approve every save. Notes and docs become an inspectable, source-backed Markdown wiki; recall is hybrid, local, and measured in the open. One memory, every agent, your machine.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
+"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Agent sessions no longer start from zero: Link injects your memory automatically when a session begins, and proposes new memory when it ends — you approve every save. Notes and docs become an inspectable, source-backed Markdown wiki; recall is local and measured in the open, with optional one-command hybrid matching. One memory, every agent, your machine.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
   </script>
 <script>(function(){var T='Link \u2014 Local memory for AI agents',I='assets/favicon.svg';function e(){if(document.title!==T)document.title=T;if(!document.querySelector('link[rel=\"icon\"]')){var l=document.createElement('link');l.rel='icon';l.type='image/svg+xml';l.href=I;document.head.appendChild(l);}}e();document.addEventListener('DOMContentLoaded',e);window.addEventListener('load',function(){e();setTimeout(e,300);setTimeout(e,1200);});try{new MutationObserver(e).observe(document.head,{childList:true});}catch(_){}})();</script>
 </body>
diff --git a/link.py b/link.py
index c666d61c..c396b3a5 100644
--- a/link.py
+++ b/link.py
@@ -1614,12 +1614,32 @@ def recall(
         }, indent=2))
         return 0
 
+    miss_hint = ""
+    if not results:
+        records = _memory_records(wiki_dir)
+        if records:
+            if _core_semantic_provider() is None:
+                miss_hint = (
+                    "These memories exist but your words did not match any. Paraphrase matching "
+                    "(semantic recall) is off by default. Turn it on to find memories phrased "
+                    "differently:\n"
+                    "  pip install \"link-mcp[semantic]\"\n"
+                    f"  {_display_command(['link', 'semantic', str(target), '--setup'])}"
+                )
+            elif _core_load_semantic_embedder() is None:
+                miss_hint = (
+                    "These memories exist but your words did not match any. Finish enabling "
+                    "paraphrase matching (semantic recall):\n"
+                    f"  {_display_command(['link', 'semantic', str(target), '--setup'])}"
+                )
+
     code, text = _core_render_recall_text(
         query=query,
         results=results,
         include_archived=include_archived,
         project=project_name,
         target=target,
+        miss_hint=miss_hint,
     )
     _print_text(text)
     return code
@@ -2265,7 +2285,10 @@ def _configure_link_command_display() -> None:
     if os.environ.get("LINK_CLI_COMMAND"):
         _core_set_link_command_override(None)
     else:
-        _core_set_link_command_override([sys.executable, str(ROOT / "link.py")])
+        # Source-checkout runs: show a friendly `python3 link.py` in generated
+        # commands, not the raw interpreter path (e.g. python@3.14). The
+        # absolute link.py path stays for paste-safety from any directory.
+        _core_set_link_command_override(["python3", str(ROOT / "link.py")])
 
 
 def verify_mcp(
@@ -2517,6 +2540,19 @@ def onboard(
                 "next_actions": [],
             })
 
+    # Surface the automatic-memory (hooks) path: without this, users who follow
+    # the guided onboarding never discover the flagship 1.6 feature.
+    for connection in connections:
+        agent_name = str(connection.get("agent") or "")
+        if agent_name and _core_supports_agent_hooks(agent_name) and "session_hooks" not in connection:
+            connection["hooks_command"] = _display_command(
+                ["link", "onboard", str(target), "--agent", agent_name, "--hooks", "--write"]
+            )
+    hooks_agents = [
+        agent for agent in _onboard_agent_names(agents, all_agents)
+        if _core_supports_agent_hooks(agent)
+    ]
+
     status_payload = _core_link_status(wiki_dir, version=LINK_VERSION, include_validation=True)
     starter_payload = _core_starter_prompt_payload(target, project=project)
     prompts = starter_payload.get("prompts", [])
@@ -2553,6 +2589,12 @@ def onboard(
             _display_command(["link", "onboard", str(target), "--agent", agent])
             for agent in ("codex", "claude-code", "cursor")
         ],
+        "hooks_hint": (
+            "Make memory automatic — add --hooks (Claude Code, Codex, Cursor): the memory brief "
+            "is injected at session start and proposals are captured at session end, so no agent "
+            "has to remember to call Link. Example:\n"
+            f"  {_display_command(['link', 'onboard', str(target), '--agent', 'claude-code', '--hooks', '--write'])}"
+        ) if hooks_agents or not connections else "",
         "url": f"http://127.0.0.1:{port}",
     }
 
diff --git a/mcp_package/link_core/cli_memory.py b/mcp_package/link_core/cli_memory.py
index 875400de..687023f7 100644
--- a/mcp_package/link_core/cli_memory.py
+++ b/mcp_package/link_core/cli_memory.py
@@ -207,6 +207,7 @@ def render_recall_text(
     include_archived: bool = False,
     project: str | None = None,
     target: object = ".",
+    miss_hint: str = "",
 ) -> tuple[int, str]:
     lines = [f"Link memory recall: {query}"]
     if project:
@@ -215,8 +216,10 @@ def render_recall_text(
         lines.append("Including archived/stale memories")
     lines.append("")
     if not results:
+        lines.append("No matching memories found.")
+        if miss_hint:
+            lines.extend(["", miss_hint])
         lines.extend([
-            "No matching memories found.",
             "",
             "Next:",
             f"  Add one: {_shell_words('python3', 'link.py', 'remember', 'Memory to keep', target)}",
diff --git a/mcp_package/link_core/cli_runtime.py b/mcp_package/link_core/cli_runtime.py
index d6b47543..c9864fb8 100644
--- a/mcp_package/link_core/cli_runtime.py
+++ b/mcp_package/link_core/cli_runtime.py
@@ -275,10 +275,16 @@ def render_proof_text(payload: Mapping[str, object]) -> tuple[int, str]:
         "Cross-agent memory continuity works" if ready else "Cross-agent memory proof needs attention",
         "",
         "What happened",
-        f"1. Workspace: {'created' if created else 'reused'} local Markdown wiki.",
+        f"1. Workspace: {'created' if created else 'reused'} a throwaway demo wiki (not your real memory).",
         f"2. Memory: {memory_status}: {title}",
         f"3. Recall: {recall_status} through the same bounded recall path used by CLI, skills, and MCP.",
         "",
+        "What this means for you",
+        "- Save something once; any of your agents can recall it later, from plain local files.",
+        "- Ready for real use? Create your durable workspace and wire an agent:",
+        f"    {display_command(['lnk', 'onboard'])}",
+        "    (this proof workspace is a demo — your memory will live at ~/link)",
+        "",
         "Try it with two agents",
         f"Agent A: {prompts.get('agent_a', 'remember that this project uses Link')}",
         f"Agent B: {prompts.get('agent_b', 'start with Link before we continue')}",
@@ -402,6 +408,8 @@ def render_onboard_text(payload: Mapping[str, object]) -> tuple[int, str]:
                     if action.get("label") == "write config":
                         lines.append(f"  Write when ready: {action.get('command_text')}")
                         break
+                if connection.get("hooks_command"):
+                    lines.append(f"  Make memory automatic (recommended): {connection.get('hooks_command')}")
                 if restart_hint:
                     lines.append(f"  After writing: {restart_hint}")
             elif state == "updated":
@@ -417,6 +425,9 @@ def render_onboard_text(payload: Mapping[str, object]) -> tuple[int, str]:
             lines.append("- not connected yet. Preview an agent config with:")
             for command in payload.get("agent_examples", []):
                 lines.append(f"  {command}")
+    hooks_hint = str(payload.get("hooks_hint") or "").strip()
+    if hooks_hint:
+        lines.extend(["", *hooks_hint.splitlines()])
 
     prompts = _first_mapping_items(payload.get("prompts"), 4)
     lines.extend(["", "Ask your agent"])
diff --git a/scripts/prepare_release.py b/scripts/prepare_release.py
index cd7b3c0f..2d7ed236 100644
--- a/scripts/prepare_release.py
+++ b/scripts/prepare_release.py
@@ -230,6 +230,12 @@ def main() -> int:
     print("After the PR merges and CI passes, publish with:")
     for command in release_commands(args.version):
         print(command)
+    print("")
+    print(
+        "Then bump the Homebrew tap (gowtham0992/homebrew-link) to "
+        f"{normalize_version(args.version)} so `brew install` serves this "
+        "version — otherwise new users get an older Link than the docs describe."
+    )
     return 0
 
 
diff --git a/tests/test_cli_runtime_core.py b/tests/test_cli_runtime_core.py
index 01a433c7..c67c805e 100644
--- a/tests/test_cli_runtime_core.py
+++ b/tests/test_cli_runtime_core.py
@@ -240,7 +240,8 @@ def test_render_proof_text(self):
 
         self.assertEqual(code, 0)
         self.assertIn("Cross-agent memory continuity works", text)
-        self.assertIn("Workspace: created local Markdown wiki", text)
+        self.assertIn("throwaway demo wiki", text)
+        self.assertIn("What this means for you", text)
         self.assertIn("Memory: created and reviewed", text)
         self.assertIn("same bounded recall path used by CLI, skills, and MCP", text)
         self.assertIn("Try it with two agents", text)
diff --git a/tests/test_link_cli.py b/tests/test_link_cli.py
index dbf307d7..33c2b3f6 100644
--- a/tests/test_link_cli.py
+++ b/tests/test_link_cli.py
@@ -3030,5 +3030,64 @@ def test_connect_hooks_preview_includes_session_hooks_payload(self):
         self.assertIn(str(target / "link.py"), session_hooks["events"]["SessionStart"])
 
 
+class NewUserFrictionTests(unittest.TestCase):
+    def test_recall_miss_hints_at_semantic_when_memories_exist(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-miss-hint-"))
+        target = tmp / "wiki-root"
+        with redirect_stdout(StringIO()):
+            link_cli.init_wiki(target)
+            link_cli.remember(target, "I prefer short PR descriptions with a one-line summary first",
+                              memory_type="preference")
+
+        out = StringIO()
+        with redirect_stdout(out):
+            code = link_cli.recall(target, "how do I like my pull requests written")
+
+        self.assertEqual(code, 0)
+        text = out.getvalue()
+        self.assertIn("No matching memories found", text)
+        # The whole point: a paraphrase miss must point the user at semantic.
+        self.assertIn("semantic recall", text.lower())
+        self.assertIn("--setup", text)
+
+    def test_recall_miss_on_empty_wiki_gives_no_semantic_hint(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-miss-empty-"))
+        target = tmp / "wiki-root"
+        with redirect_stdout(StringIO()):
+            link_cli.init_wiki(target)
+
+        out = StringIO()
+        with redirect_stdout(out):
+            code = link_cli.recall(target, "anything at all")
+
+        self.assertEqual(code, 0)
+        # No memories yet: don't nag about semantic, just say add one.
+        self.assertNotIn("semantic recall", out.getvalue().lower())
+
+    def test_onboard_surfaces_the_hooks_path(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-onboard-hooks-"))
+        target = tmp / "link"
+
+        out = StringIO()
+        with redirect_stdout(out):
+            code = link_cli.onboard(target)
+
+        self.assertEqual(code, 0)
+        text = out.getvalue()
+        self.assertIn("Make memory automatic", text)
+        self.assertIn("--hooks", text)
+
+    def test_onboard_agent_preview_offers_hooks(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-onboard-agent-hooks-"))
+        target = tmp / "link"
+
+        out = StringIO()
+        with redirect_stdout(out):
+            code = link_cli.onboard(target, agents=["claude-code"])
+
+        self.assertEqual(code, 0)
+        self.assertIn("Make memory automatic (recommended)", out.getvalue())
+
+
 if __name__ == "__main__":
     unittest.main()

From b1b2684fe114ed7fbb5c5b78804326c5a5aa322a Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 22:45:06 -0600
Subject: [PATCH 18/25] Don't re-nag about --hooks in onboard once hooks are
 installed

Second cold new-user walk: after 'onboard --agent X --hooks --write'
succeeded, the generic 'add --hooks' teaching hint still printed at the
bottom, telling the user to do the thing they just did. Suppress the
generic hint when the user already passed --hooks; the teaching still
fires for users who onboard without it.
---
 link.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/link.py b/link.py
index c396b3a5..8a7b9967 100644
--- a/link.py
+++ b/link.py
@@ -2594,7 +2594,7 @@ def onboard(
             "is injected at session start and proposals are captured at session end, so no agent "
             "has to remember to call Link. Example:\n"
             f"  {_display_command(['link', 'onboard', str(target), '--agent', 'claude-code', '--hooks', '--write'])}"
-        ) if hooks_agents or not connections else "",
+        ) if (hooks_agents or not connections) and not hooks else "",
         "url": f"http://127.0.0.1:{port}",
     }
 

From 064e0ce8aebf2e771fb02fd9ccb929cf3242c54f Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 22:57:28 -0600
Subject: [PATCH 19/25] Add an animated aha demo to the docs (self-contained
 SVG + vhs tape for README GIF)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The cold new-user walk showed the two mind-blown moments were told in
prose but never shown. Now they are:

- docs/assets/link-aha.svg: a hand-built, brand-matched animated terminal
  (plain text, no external runtime, no binary, theme-safe dark terminal)
  looping the two aha moments — recall that matches 'how should I name my
  git branches' to a 'feat/short-topic' memory (meaning, not keywords),
  then a new agent session greeted with memory automatically. Embedded at
  the top of the Getting Started page; registered in the media verifier.
- docs/media/link-aha.tape: a charmbracelet vhs script that renders the
  matching README GIF from real lnk commands, with the one-time render
  command in its header. The GIF is not checked in until rendered, so no
  binary or broken reference lands early.

Option 2 (the site SVG) ships now; option 1 (the README GIF) renders with
one 'brew install vhs' when ready.
---
 CHANGELOG.md                   |  2 +
 docs/assets/link-aha.svg       | 89 ++++++++++++++++++++++++++++++++++
 docs/getting-started.html      |  4 ++
 docs/media/README.md           | 13 +++++
 docs/media/link-aha.tape       | 43 ++++++++++++++++
 scripts/generate_docs_media.py |  1 +
 6 files changed, 152 insertions(+)
 create mode 100644 docs/assets/link-aha.svg
 create mode 100644 docs/media/README.md
 create mode 100644 docs/media/link-aha.tape

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8446f1dd..9df004a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,8 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 
 ## [Unreleased]
 
+- Added an animated "aha" demo to the Getting Started page: a self-contained SVG (`docs/assets/link-aha.svg`, plain text, no external runtime, animates in any browser) showing the two moments Link is built for — recall that matches by meaning rather than keywords, and memory injected into a new agent session automatically. Ships a charmbracelet vhs tape (`docs/media/link-aha.tape`) that renders the matching README GIF from real `lnk` commands.
+
 - Fixed first-ten-minutes friction found by walking Link cold as a brand-new user:
   - `lnk onboard` now surfaces the automatic-memory path: it explains `--hooks` and prints the ready-to-run `--agent <hook-capable> --hooks --write` command, and each hook-capable agent preview offers "Make memory automatic (recommended)". Previously the flagship 1.6 feature was invisible in the guided setup.
   - A recall that finds nothing while memories exist now tells the user paraphrase matching (semantic recall) is off by default and how to turn it on, instead of a bare "No matching memories found". The README's paraphrase example is reframed as opt-in so it never reads like a broken default, and the landing hero calls hybrid recall optional.
diff --git a/docs/assets/link-aha.svg b/docs/assets/link-aha.svg
new file mode 100644
index 00000000..83b73855
--- /dev/null
+++ b/docs/assets/link-aha.svg
@@ -0,0 +1,89 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 720 300" role="img"
+     aria-label="Link demo: recall finds a memory phrased in different words, and a new agent session is greeted with memory automatically.">
+  <style>
+    .win { fill:#221c12; stroke:#3b342a; }
+    text { font-family:'SF Mono','Menlo','Consolas',ui-monospace,monospace; font-size:15px; opacity:0; }
+    .cmd { font-weight:500; }
+    .caret { fill:#e0955f; animation:blink 1000ms steps(1) infinite; }
+    @keyframes blink { 0%,50%{opacity:1} 50.01%,100%{opacity:0} }
+    @keyframes a_l1 {
+  0%,3.564% { opacity:0; clip-path:inset(0 100% 0 0); }
+  3.571% { opacity:1; clip-path:inset(0 100% 0 0); }
+  10.0% { opacity:1; clip-path:inset(0 0 0 0); }
+  43.571% { opacity:1; clip-path:inset(0 0 0 0); }
+  46.286%,100% { opacity:0; clip-path:inset(0 0 0 0); }
+}
+@keyframes a_l2 {
+  0%,11.421% { opacity:0; }
+  13.714% { opacity:1; }
+  43.571% { opacity:1; }
+  46.286%,100% { opacity:0; }
+}
+@keyframes a_l3 {
+  0%,17.85% { opacity:0; clip-path:inset(0 100% 0 0); }
+  17.857% { opacity:1; clip-path:inset(0 100% 0 0); }
+  25.0% { opacity:1; clip-path:inset(0 0 0 0); }
+  43.571% { opacity:1; clip-path:inset(0 0 0 0); }
+  46.286%,100% { opacity:0; clip-path:inset(0 0 0 0); }
+}
+@keyframes a_l4 {
+  0%,27.136% { opacity:0; }
+  29.429% { opacity:1; }
+  43.571% { opacity:1; }
+  46.286%,100% { opacity:0; }
+}
+@keyframes a_l5 {
+  0%,31.421% { opacity:0; }
+  33.714% { opacity:1; }
+  43.571% { opacity:1; }
+  46.286%,100% { opacity:0; }
+}
+@keyframes a_s1 {
+  0%,49.993% { opacity:0; }
+  52.286% { opacity:1; }
+  94.286% { opacity:1; }
+  97.0%,100% { opacity:0; }
+}
+@keyframes a_s2 {
+  0%,56.421% { opacity:0; }
+  58.714% { opacity:1; }
+  94.286% { opacity:1; }
+  97.0%,100% { opacity:0; }
+}
+@keyframes a_s3 {
+  0%,62.136% { opacity:0; }
+  64.429% { opacity:1; }
+  94.286% { opacity:1; }
+  97.0%,100% { opacity:0; }
+}
+@keyframes a_s4 {
+  0%,67.136% { opacity:0; }
+  69.429% { opacity:1; }
+  94.286% { opacity:1; }
+  97.0%,100% { opacity:0; }
+}
+@keyframes a_s5 {
+  0%,75.707% { opacity:0; }
+  78.0% { opacity:1; }
+  94.286% { opacity:1; }
+  97.0%,100% { opacity:0; }
+}
+  </style>
+  <rect class="win" x="1" y="1" width="718" height="298" rx="12"/>
+  <rect x="1" y="1" width="718" height="34" rx="12" fill="#1a150d"/>
+  <circle cx="24" cy="18" r="5" fill="#e06c60"/>
+  <circle cx="44" cy="18" r="5" fill="#e0b34f"/>
+  <circle cx="64" cy="18" r="5" fill="#7fae8f"/>
+  <text x="360" y="23" text-anchor="middle" fill="#8a8174" style="font-size:12px;opacity:1;letter-spacing:.08em;">lnk · local agent memory</text>
+    <text x="30" y="78" class="cmd" fill="#f3ece0" style="animation:a_l1 14000ms infinite;">$ lnk remember "feat/short-topic branch names"</text>
+  <text x="30" y="106" class="out" fill="#86c79a" style="animation:a_l2 14000ms infinite;">✓ saved to local memory</text>
+  <text x="30" y="150" class="cmd" fill="#f3ece0" style="animation:a_l3 14000ms infinite;">$ lnk recall "how should I name my git branches"</text>
+  <text x="30" y="178" class="out" fill="#86c79a" style="animation:a_l4 14000ms infinite;">✓ feat/short-topic branch names</text>
+  <text x="52" y="204" class="note" fill="#e0955f" style="animation:a_l5 14000ms infinite;">→ matched by meaning, not keywords</text>
+  <text x="30" y="96" class="dim" fill="#8a8174" style="animation:a_s1 14000ms infinite;">— you open a new agent session —</text>
+  <text x="30" y="140" class="out" fill="#e0955f" style="animation:a_s2 14000ms infinite;">Link memory · injected automatically</text>
+  <text x="30" y="168" class="out" fill="#f3ece0" style="animation:a_s3 14000ms infinite;">• prefers feat/short-topic branch names</text>
+  <text x="30" y="196" class="out" fill="#f3ece0" style="animation:a_s4 14000ms infinite;">• keep PR descriptions short</text>
+  <text x="52" y="240" class="note" fill="#e0955f" style="animation:a_s5 14000ms infinite;">no one asked. it just remembered.</text>
+  <rect class="caret" x="30" y="270" width="9" height="16"/>
+</svg>
diff --git a/docs/getting-started.html b/docs/getting-started.html
index 44827430..8bea1ecf 100644
--- a/docs/getting-started.html
+++ b/docs/getting-started.html
@@ -59,6 +59,10 @@ <h1>Prove that your agent can remember.</h1>
         <a href="#semantic">Semantic recall</a>
       </aside>
       <article class="doc-content">
+        <figure class="screenshot-card media-wide" style="margin-top:0">
+          <img src="assets/link-aha.svg" alt="Animated demo: lnk recall finds a memory phrased in completely different words, and a new agent session is greeted with your memory automatically." width="720" style="max-width:100%;border-radius:12px">
+          <figcaption>The two moments Link is built for: recall that matches by meaning, and memory that shows up on its own.</figcaption>
+        </figure>
         <h2 id="demo">1. Prove The Memory Loop</h2>
         <p>Start with <code>lnk proof</code>. It creates a clean local workspace, writes one reviewed memory, then recalls it through the same bounded path used by CLI, skills, and MCP. This proves the core product before you configure an agent or open the web viewer.</p>
         <p>macOS with Homebrew:</p>
diff --git a/docs/media/README.md b/docs/media/README.md
new file mode 100644
index 00000000..17f9c5a9
--- /dev/null
+++ b/docs/media/README.md
@@ -0,0 +1,13 @@
+# Docs media
+
+- `link-aha.svg` (in `../assets/`) — the animated "aha" demo used on the
+  Getting Started page. Self-contained SVG (plain text, no external runtime),
+  animates in any modern browser. Regenerate by editing the generator snippet
+  in the 1.6 changelog history or hand-editing the SVG.
+- `link-aha.tape` — charmbracelet [vhs](https://github.com/charmbracelet/vhs)
+  script that renders the README GIF (`../assets/link-aha.gif`) from real `lnk`
+  commands. See the header of the tape for the one-time render command; the GIF
+  is not checked in until rendered.
+
+Other GIFs/screenshots under `../assets/` are real product captures, verified
+(not generated) by `scripts/generate_docs_media.py`.
diff --git a/docs/media/link-aha.tape b/docs/media/link-aha.tape
new file mode 100644
index 00000000..73eb3a28
--- /dev/null
+++ b/docs/media/link-aha.tape
@@ -0,0 +1,43 @@
+# Link "aha" demo — the paraphrase-recall moment, for the GitHub README.
+#
+# Renders a crisp, deterministic GIF (no synthetic frames) with charmbracelet vhs.
+#
+# One-time render (needs ffmpeg, which most machines have):
+#   brew install vhs          # or: go install github.com/charmbracelet/vhs@latest
+#   pip install model2vec     # the fast local semantic tier
+#   cd docs/media && vhs link-aha.tape
+# Then wire it into README.md:
+#   <img src="docs/assets/link-aha.gif" alt="Link recall finds a memory phrased in different words" width="720">
+# and add "link-aha.gif" to REQUIRED_ASSETS in scripts/generate_docs_media.py.
+
+Output ../assets/link-aha.gif
+
+Require lnk
+
+Set Shell bash
+Set FontSize 22
+Set Width 1240
+Set Height 560
+Set Padding 44
+Set Theme { "background": "#221c12", "foreground": "#f3ece0", "cursor": "#e0955f", "black": "#221c12", "green": "#86c79a", "brightBlack": "#8a8174", "white": "#f3ece0" }
+
+# ── prep the demo workspace off-screen ──
+Hide
+Type "export L=$PWD/.aha-demo; rm -rf $L; lnk init $L >/dev/null 2>&1" Enter
+Type "lnk remember 'I like feature branches named feat/short-topic, never long ones' $L --type preference >/dev/null 2>&1" Enter
+Type "lnk semantic $L --setup >/dev/null 2>&1" Enter
+Type "clear" Enter
+Show
+
+# ── the moment: ask in totally different words, it finds it ──
+Sleep 800ms
+Type@85ms "lnk recall 'how should I name my git branches'"
+Sleep 600ms
+Enter
+Sleep 2600ms
+Type@85ms "# different words, same memory — matched by meaning, not keywords"
+Sleep 2200ms
+
+# ── cleanup off-screen ──
+Hide
+Type "rm -rf $L" Enter
diff --git a/scripts/generate_docs_media.py b/scripts/generate_docs_media.py
index 66c5acb7..e79a530f 100644
--- a/scripts/generate_docs_media.py
+++ b/scripts/generate_docs_media.py
@@ -27,6 +27,7 @@
     "link-cli.png",
     "link-mcp.png",
     "link-memory-flow.svg",
+    "link-aha.svg",
     "link-ui-tour.gif",
     "link-cli-tour.gif",
     "link-mcp-agent-chat.gif",

From a543c75c1008dbddd58d2eb40f6700e536cf60b4 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 23:12:36 -0600
Subject: [PATCH 20/25] Render the README aha GIF from real lnk commands (vhs)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Rendered docs/assets/link-aha.gif (144K) with charmbracelet vhs from the
checked-in tape: real 'lnk recall' output showing a memory saved as
'Name branches feat/short-topic, never long' surfacing for the query
'how should I name my git branches' — different words, match: moderate,
matched by meaning. Placed near the top of the README with a caption,
registered in the media verifier.

Hardened the tape's cleanup (capture the original dir before cd) and
gitignored docs/media/.aha-demo so a render can never leave a stray
workspace to be committed.
---
 .gitignore                     |   3 +++
 CHANGELOG.md                   |   2 +-
 README.md                      |   5 +++++
 docs/assets/link-aha.gif       | Bin 0 -> 147338 bytes
 docs/media/link-aha.tape       |  33 +++++++++++++++++----------------
 scripts/generate_docs_media.py |   1 +
 6 files changed, 27 insertions(+), 17 deletions(-)
 create mode 100644 docs/assets/link-aha.gif

diff --git a/.gitignore b/.gitignore
index f20faf58..3b3253a6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -81,3 +81,6 @@ Link Console Handoff.html
 
 # Local editor/agent tooling
 .claude/
+
+# vhs demo render workspace
+docs/media/.aha-demo/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9df004a2..ce3a3c60 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,7 +6,7 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 
 ## [Unreleased]
 
-- Added an animated "aha" demo to the Getting Started page: a self-contained SVG (`docs/assets/link-aha.svg`, plain text, no external runtime, animates in any browser) showing the two moments Link is built for — recall that matches by meaning rather than keywords, and memory injected into a new agent session automatically. Ships a charmbracelet vhs tape (`docs/media/link-aha.tape`) that renders the matching README GIF from real `lnk` commands.
+- Added an animated "aha" demo to the Getting Started page: a self-contained SVG (`docs/assets/link-aha.svg`, plain text, no external runtime, animates in any browser) showing the two moments Link is built for — recall that matches by meaning rather than keywords, and memory injected into a new agent session automatically. The README shows the matching recorded GIF (`docs/assets/link-aha.gif`), rendered from real `lnk` commands via a checked-in charmbracelet vhs tape (`docs/media/link-aha.tape`) so it is reproducible, not synthetic.
 
 - Fixed first-ten-minutes friction found by walking Link cold as a brand-new user:
   - `lnk onboard` now surfaces the automatic-memory path: it explains `--hooks` and prints the ready-to-run `--agent <hook-capable> --hooks --write` command, and each hook-capable agent preview offers "Make memory automatic (recommended)". Previously the flagship 1.6 feature was invisible in the guided setup.
diff --git a/README.md b/README.md
index f4d6739f..6d40eadb 100644
--- a/README.md
+++ b/README.md
@@ -48,6 +48,11 @@ The wiki is the storage layer. The product is durable memory that stays on your
 machine, remains readable in plain files, and can be shared across multiple
 agents instead of locked inside one vendor profile.
 
+<p align="center">
+  <img src="docs/assets/link-aha.gif" alt="lnk recall finds a memory saved in completely different words — matched by meaning, not keywords" width="760">
+</p>
+<p align="center"><em>Ask in your own words; Link matches by meaning, not keywords. All local, all plain files.</em></p>
+
 ## How It Works
 
 Link gives agents four simple moves:
diff --git a/docs/assets/link-aha.gif b/docs/assets/link-aha.gif
new file mode 100644
index 0000000000000000000000000000000000000000..d14e3d447f9b1d4e1a1899d9116f1f0fd2ec6217
GIT binary patch
literal 147338
zcmWiedt6KZAIHzx{n}RRveISUue9#d^{jPSSBntBQdl7?Aym$`T19CQLbOzb_>MyE
zTSXU@A%w7$Bw+}-_Urd}ydR&(`Rkm=`+Uy(eBSTZ^A#Qu#+sW1peMl}({2C&AOQdk
z09X(pAORgLK*a-kB+!t8rql3reP3fe%q#=aEJL2D0mamiU}{J<qaw_Vbj*!x%#A7L
zCNv9UQwtL+!<fvNrOPlivZNs_jdiR{^sG#2R%Qm)7RENFR2y>xTO+isnSrgDv#mMJ
z)?y~CZ7q%LteJM!!S+^k2TMZ-Yk`xMiIdGt%yPD#<!oc@Y-{RbW8`9E>SAv;+Y~p)
z!NS$v#MR#1)oDJ{!Hnr->E>wZ<^sDrTe~}Zc~}xXTo|4%R$jAhy<Ba5+#FaoIxKg`
zxo$RdXI2j<Uw1oS4@W;Q=Ku%Y058YDxy&FR*PxkoE)()w3Hcph`?|9IT!Z~Qf&)A`
zvkgOoyu%=$Fm`Tupl5iXPdMZi&h`msv$)<?+#vTT4l6p$KPJpCCOj}Ud@e7N&5N#`
z9~rp7-)cb=v>=)jAH|7}3675mT^JL#FqX3@ZqH&~=;Ao;l3>Rrabe41{FlW?EnC#N
zd{Oj@MNumj#jae$U70YCALW^}Z2qdHv8$G?Shf7rs+G@@6X&NS#-}WgU%eu3^~&pO
zS1lIs7p<G`y)I?R`Zdeb*CeE`U9oX(qA)EfV<|f$H7Ro)KP!Fpmh|MU=_|Kptl63&
z$QBB=uL|G3Y3=q+X*;q~bF<U)wxs24-MDimvN!D9HWNa4TL!#+qc}B2ydzVxLzthr
zB0ndiAU9K*w?(=$s|en*TarB!B^%>PM42Vh9c4wi<;8h>vzP5F+_G;synm0RQYJlA
zvg2^x%ESALjvgqfmaLW^Dy=)Zx4t;_<lgP4Ys$~m9y(W<cm8yBQ~8F=$HXm)`fJUn
zt{>TY<3vg8HN~BJ_>SU0hw|dxGevjXT6*tXS1U@@myg`9Tz~(J^#0kx2i><G+*Llh
zb>eYf`;(^9r<cl~sa4M&biBA)@#68_mj_q9>^%3XV&%}y!>^yKhpW>^_AMQ4myf>c
zfA{*y$I<7X$6tM&82X`o^Xu!|zu(_a|M@&U{S%l5ET@UFq45hiY+k7Q93~Q+sRzrS
zC=?2?09<CSXG&ud1aQ+p0M3-FkgFs(np0w@qNc5oY8_d{J%9Z6Zn{U>VCVVTjxq*k
zmubX>x~_c=3r;6?U8ui%keS?F714B}_Xum#_+VGl$$Qn1gkTog+;G2^yU%HPck`)-
zCwaAzM<Xwuesm_GDeXn~#WPR-<G1ZHi@MbKv`O&r^zyrx&OW~^9PU0Eb@|+jYuR7N
zU);U?->X|Nl4u^?q8Mr`qB*bVX*oaKA+wG;7JcQyo4b`B>t6O;X?lB4&e?4qbG7;1
z!-fTCR`g!I`2L9^`R=ipYnMJeZ`t(zW$(4ipI#{?M2pz#EuV)w_c^cZyME>CTXk(z
zb?l9+-`)>2t$WpX<Jyl;nzr537V~ai|M_+7;hB~9Zr=F)Lpyx8dfu&@e}7MXegEp-
zty|O60LDQBqYMQa5zekbBPMx|X(ZGzhoOA^MS`IM`kICzsp*!np+bh#;dPPC0m18H
zhZ7C2cez{|d%c@^$6>g{^RZyKlr`EgyvP6h*l-zyaU79_7^aStbL~!z?2Yz*H?ofx
z=J=)}eo^Y1{RwMMy*ZG$<=vZue5vDTWy*on(L;h0r$!I2zw~bOi13c%+p4F_A=N@l
z9z%t8Ud<4pj9CXjj2;hWhi>`auBsLVhKOn`O;g_1L@#H6ab@1V_iMAxRk9IyZE+mN
z708T4V3q^pr{%lGK_o75I*p3P$$vSXAq`$pWA)(EXTpqnv|UUAQ>KRw9}q{;&e`1o
zj85W`ORU`l<2;OuR<-Lq=BEh_wFHNZqV_tq!`5x6R`EsSIzHERtMEuXVZ-43b65-5
z=}e5H%&LcO!Oa56rR&9Mmut58@^Pf(5D{%c$dO*uk5hzr44U#~Cc~ASJsr<jwYQP_
zDYB9Pc_M!UB4+>@LzthHyl3t(Zy(75Yo8C;y-1XN4WkM&$U#RLGCibVur1bx;__X@
z{5&8j3w&al@hMnezov(UMMcX{gNjXDg8rEbrRDFEw!-U#0vPc8WwWXMra7d}_xMfP
z1l4g@PeUB$gnBj=@vvQjCoR4<;^X(d%1RtUjd$zy#ORM)_8qxCbg^~Xt><#6KKFiE
zKu(3(eKd9oB0s@0G~cj=ntk(v{%ULQ1$<B3D+c?fHbql^uTUap|4U3((tp{!y7%ET
zv=4q~o&vBx^|35lLaF%~r9rjyQaxnq7>!~Z<Gdw5;AeYniQB<=qVBjSRNIF*OPhoO
z{s=F8jKX<7nCA=gmjw@ok@Hwce3nG1e`1KTI{w^7Tnp?zp#o9a8-=4|g|pLTEeBE{
z?6=Nv7jvvGfesO#F<*junv0|fzQxak_EFXo3u1y2bu5`asjqi6ufL7rm%_a{T_huI
z8W=Vo9Sif&!Cc!hCZR4-wtIa!PubC!1axaVJevWLD8a?}pBw|;QIzdq4O4G2u|Xf*
zN-34;YbVCS9WzH8ur3TxeD~$|unYj_q5)5|K?p;c^X>*h{Lt<Wn{FQ&aX?pw-d17F
z*$?{7=S%PJfN$!3ae$07=N(E^-ZZ}r#+)tz@$!mrcbOxFr`gl{?4jkC@-mk}7~=?Y
zZ*CEitgX(^Qp=wF{XUZ$>i#@E4RqT<DMA76$c8@)5vKPkn@~K)fnSdxhNcIp&oho0
zI9NSLgXRi{wwo*B<t!x-msiI-XOlvuS&68qWYcd-Y;Oa5I+((MP5-u_u?DT(DXT^h
zgIOop@^{hH*KG!W^{o(fa?)naoZ=4cG2%B-Sr~t>^cNc>FucUHeEu=)yQF}~#pS5R
znpsV4*uaUQvhB?bUd&)Pg|0+cK*Q#LEAv6=`LgsuFdozJh)%$jB4qc?Tjda?Sx#Dd
ze5lr(1$i{nF`)Yh5H8Gj_7-7Kol#}~T0+2aApt6a3s!_c26J?GNAQM#XV(o83Bux7
zQ;_g_nGKsNlY};ksax0UqYp!9tB~WlRG{7AwC1Wv{)JpU&~B(B{Ex`6BqnMBU$fW9
zIfF{UK31rS1K-{O65;k$qKGz7QQS0CbHOy#NdJToL_szB2U!TB2Ndg$v$puokQlbe
zkd0P0pg@BO{AIad$K<fNC%u!o`$`*e1ZZZ%>+q+v&!V8$C}Tmp{Q=(7)J0zp>vL5`
zEpkUZ9nv|W<$xzt6k)d$axM>{SD`_fRD3|PHLXOd8WB@rMWRBEA;;?Tk&v@qLxmQy
zk>{@i_8<7xu$+eZau3$gw=^zd8(d-}zIC@jV!0yo*f@f#3xJp%4IoW2cDXSb)zn-Z
z0_CQYtF^ZH(NY-HQ!auwG}q3-q~<2VSRbGUBviua%&EDJ#p(4YY9E1jqSv^GE4of<
zJ6PUs<V{@BH06dMJ~mf9g6e0R{l$gh)?}1rQ>{?VV_{5z9J6U;m>xU3mKkg-vhCC{
zx#Pk`(35m_Rw4FMbXDU6_t$O`aLCX5&4W%1m1Orz%=#P-KsG#dy39K5GrhxekMOEd
zPOIsOj~K6CE(w$@0PNC)^;?bNXbsVbZf>~G>-+u!=0}q~tOSf&UYgZkYd#E1DWosn
zn;Meok@OG2OEsj-Nh{-L%!|J1Lr4tEy0}M*@r=$TbJT9ucm~R+K}8f))|!8A2?G`|
z@mm_K^QU-)z5^gR)5`{FI?%rNX^)P>h|1{5^Yl7hF&s<JG0AHA5nSX)&UEoJ@0)f=
z3^-SVjlc5b@TtjQpZ<)}+*FatI|bISA!$$U)M5s<GSt8GzT2`y>JfHjn9ueaQqq$)
z)6)a2us}^whM?`0uSK}^d^P*-Hi#NHnC~&6D)7cxV{9-DkY6PXDcVe*F!C20>mf+_
z48s@vs(}6>l9%V%<@uf00(#<Fa!^++o!*Cj_RSz~V5z7Vr#|Vh#^W4+bfAl;+ANd+
zMn8d%nwwP=xn!w~7(GN+3#H?WKam9L;Fj=CD^HfDBtsuSuw`E@Kc1&pY4M<}sFt~u
zr_J$vO&UzdG=C}FkYK7g)jGBc$Ab3cD26eQe*s{HijuBK0(B$6=??=LWdE<VukSn<
z4%F6oz8~k%(NrArv4)bT3^2d@P-;Kx3y7p68otZP-<6apId^9V81#nnPLuS9O4$G<
z>OthcGRlGlB4j1$^Fbh99`=XfLCYrp*aD0wDSs8A%k_1Q0ptq>WkN<F(<!$lD7>6Z
zOAuX7Uf!mKW{H4<LJAtknSd$3`9!=7A%Z+UL!x0dd4x%ttKPgK9@U|y^uwURLO@Tp
z<Jm$=yUk`y25_0TbDWCT{Gi5oi}kbpE+gYF%iUbxVsS7gO`jrQIN{{vUuw#rT!%Tb
zX$Y0oEKGa2pJc+J8VOP3a>@ihWde|>r`1SaWoo^g5+6@_rV)SRVeC7pFK-k7LOLV{
z=^K9$o0*Wdbrn_wRA?x_sgx>4Ch2~33lRT9NFD?@)qGDpfS%%bO$|#5JE&9ut=3T5
zn8<!cn2`o~{7cIIwcCD+5WzxpwiZ{c!K7;tWF|<HgU5fYt_!D9`MAfSexqE!e@gPY
znd4bQd`HK3tH~(kQe^o8Q$B!}`%Y;n`(R+5lKhv7-=i$}&Ld<gDC2w_4hs9hAl=bJ
z*h6HGZ^*~3z(zIspMu~-)17CHOXZ<gGjJ0c$|W8WXPfp-NL(hw-dNyu@Ipc>A1i>+
zsX~0$FwSPW9r%zR={J|F1H>dk<fKXTLI|HDfX!uya+&{m2s0nT3@a&505p{<`llu?
z0LXte9@jM#wcOrUNc=13Cc>E00B0YQgJtUcR#N(T=pzE@Y$drlMW;}KS*O943z1Ys
zz-0v#Ux{tiQ2Kc8I`{V#9RhT{S^Ja)Kjfq|8D=vdw_WJy!@~%eq@O%W8WXb`M(Ng5
zReI84D*lFN*)z}RYDEw(1GuEzm7E}bvKORpBLpuHZv?_R0Iq8XHdC;3rI2aKBgCh~
zCTSP^HAqLWK`sxI&k%L+ib}Ik(gQQ!0(PAm1FLbajHKTD%KW<It<zSBYKGs49J{)B
zZMP7$tzeal5}%C6-{euU>tk#$ZSnQMH;(O6v{3zvcJ?VSiAuDTPb`%IoqI`tl{#rk
z^fq7t#o%yNGm;-dE(gf{3}DiM+DBilrdt>?L9!AF!RVd*Qoa!F1R-9HafVn&6;#qq
zX07Kqu~mql3xRkhKKy{rgi<F@hFES*jj5w_%ShdtB;wLV9!hAR8qchwXpa}h$N;r{
zuAPRofK&dB3v|gT<5cY5D^wq7X3z&+A;e`Ic^(7Y9xvtz0SuFnHj2esBODn3N(Q<s
zP-7mXEA2q02AcylNV~CO7~=*5N2Zl|%@9Bmf=8GKc2}%gpih}6LwLYo3lkQ=;laju
zfLW<x00*IhKpBuE-2DUws9GREE$){^*=!+)XOW^9>G*PRQ$*BOd4zm#l)fS$9{@Tu
zlokeXlqdF4AH!OLTX+o*(i-wK=ojzimCjA`<uCI6ju>bMOcjK8Gz5jmrF;eog(-x$
zYnhCr=JLahhj!H~^PVtHQ17SEyD*^IuZ{sUt0{fzMpq+}a|1a=$hHI)ypSOz@hIau
zQumcAoDg+`cC<eHXr~v(7vtojsX>5XI0N_4_w05d${0GffQHwf`Jc*39{Vwy4$dD!
zo(S{A&z%-#{V3k`;sVa&5m`)aBHX|5m#MQ=2>3dJKG52k=C+pykQiWwGEUV=CBlSo
z>AGQPrnz5c_N(TXifPS6=)j0M8pKXHZYPX3k%Qzmjz-|Cr$o3>ksiFuTXrDrg!cL}
z<XIl&TVaS=i!T@mX?jTcCu|v19&Kn^SS2L#cTqZoxTLyd(mR<s6|uz0FY#(xB3yo+
zzh18#oX;TjGRa*Dlz0w0{dB-TA(12l{flHWzO$tQ(<RG%qDlIxCb<YfwvcSj(P{O&
zKF%a(K)^{}Ora)I0G)y>kYk%DUD@P*V8K5HM&4b9U{-c*$Nv_R<EJ%c;VGoBePGOC
z$~bi9?iCCS;SwS5n&)T6HDO40V%s=nHv{N+MgZ0LbUga1FEvU@R{33TJ)@%rng-G+
zzcfU&V(#Ni#6?-4s~Xf}gFZq6vnA{uKt91Zs=dn51JGgyZiBqZHSEY=Ar`6jtE2+W
zN{X7A{;-|$ok}6M;4zB1mek-onm{xp>E;K#=9c{BpO+S$e<92&uZ*>ltA_c?)*~U8
z8KA=vO4j#tm2g`o^F)0IqEfE&?V#|XkVuqA|I6BCmhWPlh+UHNAB9)a0wtP8mf;y#
zGLF!Y3ED%V1=py0Le$ajUGOqI#WY|acJ+$sBNn7hh*j&rIsD^--DrmL(((iIH}0U4
zWC#~^*K8%CdJu6ZKY4Q-B9AKgt)LLM<G0SQ>tc{@$d;_rM4Iz~j?<*R@99sNm1;gf
z71ke|RZctQh~|@~c$6$*7RoZ9WEIsBBLCD-YH5_%Eb>yt)g5(iI41saIKCkmT*4H8
z!wTKe<QuzD<I22<OMO3NlxIRLN<sK1C$HnXe0{QO|6wF!%Z4Y0l#&IQdCnF46gN84
zPXCsZ6Ja1rPWc8AFFioqQ5+iI?Rw@y<>#n_{nY>Ndo=!4<9@xTG|3xZ-3=vMqWgRL
z-d9nc$S@5TdcUh#-O*INXqDkKX|A0HdrnRMCGY;Mz?bT^;#JOP9<<+WY}F3>RWX1j
zW?KA`wy;HE-H?x^Qh8nxgk^emt51YB?&ta+9ffBOf=EgR=m-;6=Rb&8M7hqt{ic|L
zv0IwM+#CMJ!AOp+6_UG?DQAQTN$nkf&wf3(*5^(5kG|9`m*j=ot$qxzosHC=$B{5h
z992Ag)Q?-<e{pw?#b5(42S5!>;RYIxBQm-wCyuY?fJyN7vzMQpT6_m6iNUIoeV6dX
zES;Er3+7XiE;8Wa0|zXX#5bWB`feGKQ+n0m`|r-ym+L&fjNBE9>MA6<3BA5eqGEX{
zJ08`Z|M-`hP&v)VZB@=BPhJA|4kmj(AM8D)za#ky{s05FTP+?XWy`2|#FAHg0KANc
zoht-R%l2&4WTvX&pDqj5hTw2}G^MgyU3xs~XyXB)8gGW}+)TXWj_i^J(r#Q#He}OO
zXR_wLy4!Q#JhxH7c<|WtAYO&o&42YX_f<K7&t&qR53UW}NA)nH7)0ydKqKp=_<d(}
zt|IzzpFxs(sBXQ~DH@A{`y+e%2S;%0;_p0JP4s0w`o$#vP6iVG7CujDUtSv1Urgy{
zJbv;TOl0Ec?0NNV18$-4!iE5(=nDW-!#8b^>ZXu>2=UB?l#NH5%qBs7XbnkozB~jK
zJiUbA_5m#H)hX3(^#Drrc6njts52gf3GIzHM>_9SKK&Ml2nI0e!sF>Mdhwmom)vJf
zd%MseD3+%@Sl==>MtLE}+-rMI(xB8bH<g0&4R)G)5h;(S;uHkScFG+sFx{QksyV&*
zv{Sq$q?>`f*-ISzirF0t1~Lf`0dlwY%r_$PX9$_fa|VQD?DCg_M*#z;UsB|l%lk+u
zJ{wC7{`%L^u;SA%b0-{+@K>($H^FDK=DM*E`E!J1*zA<K)P2!h^`JALyGQ-6a$dLG
z?Sp&hDDys*iNCBSR%nC{17}>@=GgqZZ?9AD_)mEK?98oBm81^uo<p5GeRJ5M^EqQ#
zI#x+soh1%A*Oe+HUgsr)>*q$j9Qh~fj|w2i#KcT!aOU#;pZO<ikLLGLQ*nTddIaLH
z7$}^2v^rMzP2ZQF=PJ$N3%{Us<_h2>9JD-V_VwAICzCXJiV)m@6d}eYE6|se#4|Ds
zXXD(B4<WX4wvo2^rxo^QI#F{F3}jr~w})C-0r>ckiOhl#{^zRnv17-~<E6(JGf*_1
z`-bOKr;C`?-fMJ}V7M0F3=q#v|5EUYG7XYD3s<fL1N+E0*yq+B*K1F9EZzr{t2g}-
z5&;GNk5atr-`$1%#Dr|DT1NRL$K*Vm18gHrY@<@C6%VG@Q)(GU9LFSm5&%Pe@-F@5
z#IctXnqG<$<84a%dJ{MTMXA*Yfj`xR%KSNRRXLRc)Xb{{ksf<K@Ai4emKybaxqVj*
z9S7~xRwc@yv#)Hx);~jf!qjT-Ir!7j!yRXDgQz7R-z>niwnbBL=RUme*g!%a4#@r2
zqZTg<6u7ug_CP~RZ-pWD{FK<rAKqNIl<}wi*@8AKW!X-v$}HCv_NXNRb@BpNbCS-Q
zrWKW{wexYb?jAGYiF+>#4pGKGT&vJ1H7e4cK7ZjZi{K0CqBUcW%XGlC|5*6S+Z#>v
zad^{j9v$|e$(CO&x<j+X&p1{%g6XP`d584y=F@=?#8-yDNkZ7Hs@yhIG&iRk_6z&?
z$T>#0TKjJJ8}zz4XF{zFIVLKoieZ|g&a73^Z|3^$v0^-#XMjQGQ*2m?P4`#rxNOLn
zPGvm3x&5Gx`52?b(E-*FH%-=r9mlS}kF{7FqP!;|ZciAIVT&p;CIp_<$wtx^fsBG0
z^iwKu^FrK04Hl=I4>eku?-pjfw(fk`tc~q%;bvP$&WDd=E0ILTA|79iZy{Lb(;Q{u
z>K%KR+%|ArUV|>BInc{PTB%AdK`@~^YM4HtvbD(FvrT!4^YJOxtC8+7Y+@f|sVu+M
zIV1sbchql>t&9C!a3t@0oK$it&Hc@^>-`I2IYIFKzWuS7=t;<L!{n)s{Sn>~;TE~g
zUBL)kYs;PLxNgK5-$=b|n7H}7+uD5*iRVwU1xs1|ZiF1(9g9to#Wt01^&-C_JqPmF
z=yRPcZy!o+fB|IMpP^1`S%_6JNSpJy<5;ry<~7whk2SmOP;&~t`5H(}PB%<B-Qb@(
zaco!G>C@*9>$;pbxl5RRaUe2IY+rRHoW88N`0arlT)q6i?USN42OR3Jhn5*lebE4m
zrd0j=FU0ygUFdSU=F*f}r#!2x1|p#RnDzkaN$MB%+UjJdnv|-Xl-gbi!u3kK!G@_C
zyS*`{bH%PhMILiHMzviX#}cd#)lZx6TwenwFPAXws*_h;89kOTF@!at_gRNGEwkJ5
z#*lO27+%C>U9zX6x&uCgo>xB?&RT4BsLn{h8gj=h{&TA10C&+Tdkd^(dl@)?_+5cf
z<{f<4;0nD4{r1<Z4m~hf_Lw`g++tpMz~)Db*WTFtWMyH%mZvLS**L6=j1lo7fae}e
zIITTtu~TaQvU=GXrkOJ#Q*hgSDBy$lA?rQA<mI`4GQQg1lz$F43(|o&M{X7~sHJ&*
z7UqxnIdVrNsrg-pv0Yjl0Ws&qhqvZD*4p&)?7my!m#chq&M^6;oaEbJnz%TxA4y9*
zu5$d65t!qt-u945$P0vFFPZgp_LQch@1v;rOo|54#0=L?l$Q-<AeVZ7F0@5xEBGir
z?H?U$!~jGL&*ANBzJ#k392!!-+r&4~h}2Vah;+#n9Mp!}Ak@x@C|EzYiBL*~ivy2#
zyErOC|E-YucO+^s^$mqu#-rIYYP}t$lK;8rEy+fG57_mz(AO@*LS_q@{ZmVT6GLS@
z6kznP1+#W!^#2+ZsK;mjH<d)VX~Qu7rN!bzV<mR|qrlCCp1`U5lsrwoS-Hj(Eu&KM
zSi>xz?au-}mfzAWAI5RANF0aHK|70__o+LBujnXshPrgitBRjn{n9-(UrPzKaDc3P
zEUzETTBo;qItkD{px2(~Uuba|HqG2}dp9uW>-NvoFrBF{mXpRFN0%O1?*C@)yzP%4
z9{bV0Ht^e1n)MPT;`+m*d$$)>6R9fWF0RyF?=WvQa2%cT2an7Y;*(e$voZfrg7%Hb
z&6H#82|Fan<902J&8j2Tz_f}Qbqc-KsGJ40twD$){@kNXE_kUMc7A?RKX}q3Lg`SI
zQM%5vR{tb7Z1x@qB$y@{_9f^eAInSljYCd)FgQof?oZCKGVGcPA@FQOzATB!6Yiba
zC2l2Nou0@{Ka6Kf23cTJtLv7%&avve6bT_rcC(;a6-m46x5MCUYM4iJMrrbZRSfr#
zYFhLwW0#@wYlwXdI^p&>4W(!`7O<2ya?2v*AltZ!DUM!k^C+1l(P^11#sTFeN$b5s
zsdAOA_&#Y9e9FLezyVWI!+UMlZ+u`t^uV1_!j6&P{wv`jghM4RrVM>`LmLR(C(TER
z5F|+Ak)tYjmdL<5lQDN<HAH~`X>wg#;O<=$OL5`r^(8oFEcPw&t6*YpaPQb=uC6`#
zDBO6kQtEzz$<Nru(EDuG5m1t`+g#%b-f%dV#~FGNxmu%tcLbvsf5ZwkrJ{eRfA4e*
zx<%x&jUTF|9_uYjQUJup&IqNhZ`}QC1&3bM(i`m#AP=lbFfO4F2kxJ~o?_?ov}>L;
zvtpe-@8y*-1e(D;&_t@Xy@J8?jfDX%{WQF(5};m;K@ebokfTAI`&o%~kiSu}_HD&c
z<E?yl?f0S8h4}25g>Ipi7ndvvK9>Y6PJd{Qt9ak*=)j>pt~$c1b^vj_;0RpPT8fPl
zaD&<mL$v1OS1<@G-ln^BKER18vRyed4e0QFF<DmTiU$ab#VMna4^t#)*5=cpit$Bv
z$B-lkl05hIyCqFyy=bavd5*{HlGG)46F+9nIxxR%9vynR=cjT;n+J6nCXX6N?`}w$
zEz0aY^vLsy5)6T*`X#s*9zWreXFt3RA#P*dIH!xR+C-Vgm)ybHE`3r&XOwKGGEM~G
zf84~c5@3W$CVv%JSCYocYo~^o*a<~{#)yz30C}}{)6w#;po^{s*Iy~E96AIR(@@Xn
z-`Uo;`R1l$KL+2rAO8X+*(*{93pQJFmCOcqAx-`>#Av{>WR4Q9zTkj7o_V$ETgp@Y
z)zG{p5in=!d@(Ic^VUD@w8!fjrGX`%*0<@7PDAh2Q=4*+Av!t&(wX0`)H)zNSs2xl
z3IMA6Y!W!OW7i2C@Y=e7_nqf0;%?+_>0bQu%fXJEQLl})#3{hAgEx1)bvb-wqxoi1
zCE9aMTk6AQbFn9QVPm!Lv1_3=>iUhjyF+-pFfXPxpPweF?5gf(k1!eJi?2{0zn+R*
zF^SMzDa@O!56T^1TphkKP<i?6y{}{)yU)+>y(wzGm6<Y2zFPA{W7SeqYSZR`6sO+D
z@{YluAAarK%Gvqv+pV4de!QBV#wvlvKuo3Bx*-S*QKI6N=oBR;ONq^gP!;f}-AY2U
zlGv^!WgR890HiUcVHd!u(dGQS;eHj?`!kmotlCas>x@A~nJOKdKysbRq**nqU1i#T
zoq|JHu@Dv{`&&_<)tHEpQ*Nvk*{v$4w1`X{jy86}1{L-?Ax*ce5p<T4?p8x<EWhO}
zw(v)o0J~^71k*<BlHW>{!wz-8^qfRpT3VZTe#7i4wpnwVUwfN>Kd1ZoQ6onOeQPHN
z>Q$WE%~U4FL9WDI0ZhhF0s-pjf_8?cU=8nJHA`eH0GpC8kf<V8&$7mBcuA#{D+n_E
zdCelemCgnhv`BA{OXuUj><boY2`*O&2*;{o`c$h6PGXVMdhUqGIzep97h7dJRI><X
zEU~o~OdM=mn}0`8ac2e)2WIIKvJpGfVY!`HUnXe42DoG92SmC!IpSjk=1r9DsV|J_
zDLlSYyh4q_3N9d$3U}ZzGm2!orZ7dLFl7TPJF%HEBsZlT$;0F*3JJd&bfaJvkGo@_
zFk2(`{ezz-;KWOdN^fflGnn}f(d8&sfu~7*c2R!hZ@^F^R$jxVF}Z2^U6mDGhw36O
zt6?}&&oBa<10j6{GH(VbEJ3NY$bqH0I9Mz+#%vDJ#o?-RVHC`P!^UQ{FS|e*Fx<&4
zbQD}itEIV2>CTDbs(f97S~UM1n$8Wm?I(6+h418I%;;`X4Z^*0)~;r5-?RL}^M%_R
z3U??g7G!r-!+;kZ`>(}ehsKB^gB@YayspBWF{!GttGl`9ZhMc(^)4!1MC0nMZPeG1
zgB@UZ^%R_`E7E5MU$N}A^zAjs@UWsIEi_l3{DJkkqK$qrgc;EaGOzCRnLh1bO3IFT
z<k&~ch}^6$Oyzg?>x2KHqRv<0by*@q<*wmLuMZrU--69y<+Ggoo_hx8TyvY4U?Q`3
zwNzarWy4IUXqV0TD1KooU4k3{6Zy1sswnGj@O3qIb2bu{0Jt-dzvdEnoz*uhqPu%~
zFq_rb0`;GDfVlw1F!gL|-1Ub5Ge*n|CT3|Qvl!yImO~7+$z#vL<0KJHCgx})1|xt&
zk;FS2=}mR3YY}lE2^B&nHJsi!fhXW3KG_m)KJwS$;uEhW{u;Ep5(P2x{or%vU4R1%
zWd<A~(j$S}jxV0(13Rk6;?Ii3sAQaUpX4$_kU#AM&(YN&gL&RGCxc`M#IK)b!LZnn
zmH%HkB0CZcfF$1!iT#z%)hu|jBC1ga{Aj<sIfH{|iIc|)v$T>KEa!?t=``Fz!qPk*
z#-ZVABwiG!#Kx;dsRM;wCF+H%A1&JasFw&bR7hs!jEvsUM*<xO)jGCK-ps<B7R(l*
z>1i(VA3M&#HXk!2?bt;{^5^6*D9Oqjp;ZONiR2Dd;R?msk}LWRPYc&M8KE@!)Lqf*
zbBlZuqD*Q4zbi9pJ_6f$74fqh^$t%<pfzkO%2pRDDo!C=3Ji8dqlOU2xIlo`!1Ej6
zv)R;kim-HQH%DV#mxak=V5ids)P+M;B(5l?vv9k-7}bI~&Zs`dif@VT-<lFX6<y9w
zggIm8;atF^rGSf<df8Z`SeTrK!qA_^HoD;YkcA6#AJy1CJMOjA7P&Wsx70@n5@$$_
z0`QzDUVgjKyTuJJki`C+m!^J_SA@RAi3`jI!Zl$V<S;vngqq4<lv1Bu>5s1wrERXd
z;<Okpo|P;Jy>R73*;%AO;5vid1zg2D_EDk$ncG{qgIl;r4MzSfMr$Q`ta{6Cm<Au-
zL3i5t=1IvrlY}@-T1(-g!=g`1kxP7~zdK>NTxavZ<3miKREXgnotes{)YFCQ#xV2l
zOG_Un#40PM%Whzby3E_5{+rACfAmCM9@x(xn`I)O8Q&}m`Z3|WwyouWBV3)#5cBHs
z$D<Zv0-k9NUVXNGMSlmN6F`O#Ss#P)ZxI``m>JY8J@etwV&g)V1~$`}3xwh`P#nZq
z#(x8opk<fU2{es3cJs3E-OKFbq){P~w=MZJLA4=H#40Mev08_&gt=o!tXo2ei;ngW
z<_~_@w_T2z3&W=+uuDtJx*`uL57Y5kWXKdHGiK$*z`mMU$qa;^5RMz8B^I5s<w+}e
z@>`O}E10dQ0n{pA)Y`oRc}0Z_vVpMvZf_a<^6zpvVTFMHvcz#kXw1_QuibjXVbg-C
zN`01iMa#wZ(!vxT;tr=ILA|&k<=Q6`H~HU}U%m|oVMd_GjC&IRkq0{qCE-(&ApWy+
zjHr>yS7&;k<&6~({D7HSSeK3LON!adlYY#{_$2FM<S+6PG#Y^>yAw$mgK63Ll@6i*
zJwH-9cJcD@$PHuQk=16UH$VsBF!cg<Grd5c6$j1Wc;N|B3z&3Nnn+d+Xr3VH(zm<<
zYdOM>kzdclpv8b>VWF1{rX}QKwt>|+(Gyz}o5L@<<x&?ujM5;TZlc<_;Hz&5uF^^?
z`uV*J=edWiFj@j@yNdhMs*SWFtyS5MhQjm)Nv3td1NwnaA@Fn*y>MQUN1)+S_T#bA
z(J^grgdPt-3qhlVkq`h$R>MwhW!!TscQW#Svw%eIBY(}vl`g+rmaX<S0jt&9$y(jg
zOWL9|(&J+PbBsR>!=9adI0{~NDe_5iu#P}v$S}xNlU$WLcv!p!szVo*kvc^mucH~E
zu<h%`$j;pj#f9683JXfAOOpZjsk<o<Y?e@(!90qE$vYLYW3q&u1EaA!kViMz&AItD
z_V=n>yQgkpPj{MMud5j3@_`tAcO9I_SPnu(SdR#M**EM`hNNCDb!Wg!wAdtNK*{5G
zd)9n-yk$dbNUC)li~$fX4yg=*h>)Gq!GAaX@n}jQoSLXEOxH>d>sWSP$LInv#};WW
z*DuOr7G6k*%j_&nk%_iOjMx7wKJgv9Av<mDJ^;^5mM3^wD+|*3w4Flfu~Wq<XA74#
zcq-Cmv13Pb^%o!;UTkj|NY`vkXJS|I7$v6CJua|Wr{CgEN*X=A@%#JvTb8vsz1Yq}
zPc^)q6E>0aa_yb(#lsu=4Yt8ntfK9#0<XzpVoS3-53`w3mM28hG{`N=LO<N>ReDmI
zU_NjX|0wT++1t<NWnp9mjMsonr6h!x;v#rP8R)^i`*29Pbn_Ti(?=irC=E@DVS@ST
znNkE_cl3Me+jRaWP1U<|>9dsS)Ac9be7N~$WNE8u6w(t$yjkQwX9$(XEnFg|2W!E(
zCjl!uCgj<wx=v8A;d4vGk)|!uJT(Sli0y@w_AugE^aGYGF|a5<w*^br;t4!S&{C97
z)r(Q7u;7@m^aYAI56)0(Z_hk+VZVp`wG(~gVLo6+#YA_YjchznTG0v(W^*ND2NUBt
zAVO26JLp)?1Q<(~1{OQ#unKnPiRH^TSX}<Tu44<h9tc_VEF3_Z^F;X0M~E%N(;rZb
z&0k*Wr03GH&aWOoIME6LLzSpI>iwpa^QMQo>E&E-JQm~e36JF=KdkURJt5^8ul9s7
zTPp9xe7|PRlTN4e>p#v#d$JIBJP$$%oqS%n;v6<dD1A8uY}OPeL;m^g@BE7#Pqdci
zeLdvT(vd3H*)VmAs_7rcAqRpZ<JJP+jLn3N`GG^#Bz|Eoj1iwG-g|VWAOr4X-P<nA
zcf4JO<%26UVM$C;wVudJj>#07=c%QkIOG?%j6_A@4hZS(AqrVplgdI=wT__~Kh~f8
zef9E=$=wUBw<2x+<5`~%vwI>k5D%$XyX?!pY~J|eFovw@6aN=oIGejTCmDD$ChDe2
z0e-O;>8snPAMPj3RSvKVRi8tJf2a?mcqg3Z{9V;nhU!G-O>i?4_i_~2ot=ei0MzVC
z(aii)M$8tifa)%X-=V|OJuko~8g%i<lLIk@d0I4ue-R-Ug(^;K)S_j|$)=9{t;KN;
z)A`+BijUsf+Lk7%{!ia_V5T*SKxX^ZE}p2f5H@t={Id3#Ge%o0WS#KbO;k3vqj8Bi
zoGDYtU`y#uzkcrSSQoROs>jUN0z;)&^SU$j8PrjeTRBZS*;)u>gY<{rGiZE;O;4r!
z+6RrPU+wy;e7Am?c=y#_Ee|f#o1Hf4@Sra8p!<gLNyq+%`6uU}P5XAb$6#@`R?W9W
z4Jd*<6s$|1%)JB;w+m%zJL_t+xsK+6&z^Y*3Xbv3<87e|9r)|Z@*PSKwtPCdtLoHq
zpT5cqD-s!l^4s?kS5T}vXVhA2Ng=9gudQU!MvIHdy*#rTo;&;4!wI>U#}?G&kl*0<
z5AR3qzs3@_Hi&jf@)4RtxIc=AYfDCYC`rL9B#ExC0+T}>QeaKv%7C=C{J9U;^cf&3
z^&jN-FaEC}8rA*rsWURk4&|W!W#*v~fwO+}*G8@|9+b@s9EWP7{eO-jOLfnwX1t5z
zi6<W0zdN<Hee3tSH>7#E=vJMeA6ZDUmt!z30>NCL*=s47RKlp1{S_iqU)92+%!dPQ
z_X0aogd!A=#Od`SKlAAI>>emGsECW4YrB8p(rvZ}mZV*=J-B@P&(-nM<VHD+Fv+I2
z;_T~w+RU?n+{i)yI=fI9YG+(okhpU*#Qdi~a#!GZujd8iGa)wN<kZ75553VW*lqWB
z56AlNe6f<;LOorB`#d$=Lz0^*$@Qd|@q4VTDO*6|!E7h{z>Tca3lKRC*7klP;N(70
zVwDy~d97BeX8#k=q)8s+W!-`Q#va}a_&HS@y>8mft)%(4|8uI1GC~~^_BXL<9mX>y
zg-ABi{1|QiXA5D2ehtj$6Phc!_XPZlZfb8d&WF0sRR1!1h)qdsQy=%gzxs3)`KvVv
zVTGzeV<|%3K2(%xZCTK>U;FlW|Iu!`%U*{nQ3U-&5$*0y&%XA@y~pjYzelgv^PHv%
z%PJ@?Az-bR&C^fG;98eQe+kAIPXV1aVTmrFkxYC3XhdW*qEmN#4S=-SgK9kyLzTNl
z*sS)Ozs05yVvBGKAw*HW#gs1I#HzwZWG?W_ymUX0m%Ej)Ri2B}<-f`Tb#p3u!!HIb
z2SiuBRo<~dU4n!Kgu<%hJ&rl3;H?CCu1u+$lZ7yzbFg!WGh!}#gs~}+f3`uX25aXT
zH?>x%h#Ppp(j=oPb*JUR=9?00m5oQ&tX)ki#1ZNUqvd|;pwYftNuHUPto<W+q4#%e
zTsdi(#OLdwq#YG7EwABt5A#Ta=#J&VMsS<X^rlZYc3S5*lz9M12PLSdfHD3I1TDef
zXnkr-xJZehGT4KO3=pU6#hSw~I<W_7!RkVoZWfV066}pD7=*YM01w0<a0C0%#=yS&
z^~?g(iU{<=0d_~Iw%}}3H@IeqvZ-NQNMwp=!7>;Zs0_161TaMk6y2Wz24x*Z8)<+;
zHp&GZEh>YpCso+^cBDaKQZ!Qmo0}$qQ6Ug5buS0+4hY;&B~ad6*hk?i#a@F9;~klL
zG*cCplAyHI1wi?7d7+m}4Z_;7D`NhIy$7z_*m=C8DW;rLSNGQ;EFtNFu_4s71YaKe
z&X>Stl+3LGYy<D3ru_^H_M>d{wnC@wF8^}j;LSg_Ov$?nYS#QpbdQD|A7Ow$*HhV-
zW9M1x*qb`P>G0$0cHT{=dN*V?9eMf3j@9Pam$A30YSiD}_u;9&%@>-Ee$27=A9lRA
zZGHiWZ#ijjGM=3ioLQ#Ng?>35676t$=!EQj+l%Rj#Y-b<NEZp2A5ZyJF62q?^#I7d
z*0DQYZ#vF<cGCIX&x(#09`ZL6$sTVGfu18Z^?3|&#T=Q0rM0Bw@Z0cku*mj$4WXvi
zhB#_;+Ih7cy+t6Qv~>0uf7b=|<+cY_C^4RYDpoW39FzI7dZND)E68p$Nq?x1ubZ^X
z$r)O(EmPuCF|A5pPy<I4T8Z9=+9Dk_2xEbkm%2tynz18ApUM)MX_Lr)1Md%xru9(z
z&lA?mkw$@=dPP>s<C*JQXUQ3e_Fp57c&;;Z2JvrEaLhh4+Sk;?J8x;PZSH3Tb2p0N
zxXNTY*TEU#szIj-IK-CH2k6r?XK2Xr%|;BAja>%nTeONQ<B7vhR){<khfPX<KZv}T
zL4Lga9l{mJcRR=4ldiP78lual$*IpPAt0wzAl|n6i^xYPG1<O95+jDthK-Buxp3>U
zQ@mrI36GCZD>3VOb;~$)iz4+BkbdXbMX$PDkm2%HENfN-KDtI<Jth_7*2i2M2lb{m
zEAR**d(See<;_sX`PL?EG(oZ#p;k-1wfD<np-=V(KhN{@<k)n9#PlyO+#oS}AJVkV
z;)w%CL~{Ux`)e&yxd-;Y)=+XLTjMCKm>_Wta<e61_<bzgcFtB?osie&e>%l`&s2cn
zV*~h%Jm*=j@0Xztap<0gk(f*kX>|`|kJE;({Gy(BxJaY-OWi^C{Id_$zsh7|3tYE+
zD`_p0?L<;bPMXwoY>d?0d7>-~3RJChBzNilQ*^i(nt2fDNE6;vohwaVlB=z~_@qJ7
zSh@|gX&+7+_fvZQ0ZSd#`yFu&x647d@s%$%IIm8e-RY}-(MRGCS4yVwvWyS3YkDf|
zp0VBfcH6<T<==K;>0v<)mYCf-#ZBMl;GJ)o(X1|J+P%M1|GtxO$r3;K3bois`3X~$
zJ%J?S9kOGl%pUAm3-AAH@OV~aKGAihy~Pw=vW}|U?XfcLdCDUnrzamiz&n~>Q)l`x
z!#GMVSJddWD|=+B*DmkJ^H=3}e@suk_%C#TW6^QGCB`P5w&>C<2bMc%Z?cLAjez*|
zncK3Kf83zZeTQ=#ZoSp!U9fJ-nr=5$^EhsfI6{N8;IH?MQJf3h)%IeukptxOM??tB
ze4b$>S2j)Z!xnch-y`q3tYFB{YlXGsgadfh;=YO<?-LWC!kkyrKg_}!iDy2wgsi`~
zj=#t3N5YbWKH170A3vSF_Ho>Z6%zEiW|za=^)K+yW=1dsHn05`_WtFMAzO>BC!&7+
zz%PFM>00TRy}0Fjs9M!nO$Hv4u`m2S=Qqk8{?fZR@b`<GSKh4L!<qOr^3vauXg?KK
zwydlgfrT+aRdHWGp9y>u_+La`!%$iBjIpx9=$7sI2VlvHO95TzI(S6{q{9{IR)&Pm
z*!C-wsO->tMYH~^YM(`lyE;TAD<Fk~NWTXfy|L_i?-Ao-C7Dq=uLvU50ZaZu2Kpl7
zn!TuYV8)J3X2eG{GiHzgl?&q_5sefP-TXj@3+mS?gL|iW#0N_KK>*bZAkUG|E`xzW
z5DTejRmv~AU8F$<d5jTV1dxjWlu)S~ud1|Mgh?3;7!)7$;s#D~T-uemQq!P{Ds1+1
z-9;+hBBfp{in2&Vfgl1`r8l|4`5Ub7FT$f<$F>jln2GSX8l1~3tU^ij?;~<SS{<Cv
zk0&zN1}u;a#YXc0;(+CAu8NWc(a%31`-?2*Lk@aJ1F0a!MWn9=uvu{Qz-uyBq~8n#
zLodHZupPH+T5=(Kb7YW!17@oY*bt7c(l-S$b@~<=fb|_dPQTLQCS))n37D~_)g^O3
z7YDXWEE}GFG+-N~)Z*3CkDgszPRNI8kci|`?PV^~H&y+oMj`T)x&9*kb~wKdBKgDK
zQxc~UC2<hOB_>8I0CEo;Fo9%@K%_zVeS15SIv;v${XH8p4t%9g710lb5VVW0TzM3o
z{T!ipTx*6F)TK~-Rrm>N^dNTTCF(V!(+3`r>!9}|b%cK-_&Q5nNEwm~krV*hU#XLl
zjH{x|qjrHj9s6d0*&XtWs?v8+SqGbw>i|@|m3}k)k<>q<SUs}r#%j$cy39Y^CWW1V
z0<>*b695UW`+i<Y?tk;K#9D0=vosi@G}eWkH^QRoX$h!R%OR{gK<24*2U8+g)(eBD
zVV$WOJS%c*Gfbl%r_YB-RZzjC#GC<11Mtp|l;l1rYCC{9JcM=;nPkGHE~~7M0XCy`
zOCyI2WA(%8mAcWOeibk^Gz+Z;+@6iDs0Zk`%VT*ktsNN%wVjLS&Ex~-6na45@;Cr9
z2Dsf+x^1x|4-DPBF=G~O2M2=#``c`wj(c@BGbzzZ>>MlsFl`y82)0y<%^TUS(HwUm
z_-a0k#)<NeL+GLc^v4jyAb9m%ELG8JFJ#-W+C1A4MxHaq;pc0;Ks!zF<;nbIidL&^
zktvFkHl{iq0TBB^=Z1pW*&r#TkJyZ`&uR6<wGGVRxUp&WLN|yy1<r{^dgdVX8=s*e
zaJDemg@>FiR5?Vqx#ffE_$2=^j!h!M6GGZYv!$vK@?*A3!|fTzVNRdSQrT*j&1N_t
zy|lr`g6FX<Lw8i|$dXe5Bb?k8s`&v^v?*xm@91SCu}x8Z98tOm5so~LYYu4V!ky*v
zP8ZiI4o2G9)Px?$w;4q;vRXY^ZFZ3A@Jq5mPOF`qZBl{oVj*ou06`sWnlJW9lz23Y
zO%=+Ib%33s)nrWMrvJ{g;$`UwY~GLXj4w2IIrv_)%G5O2BN{ooNaXm}ruikJ;#jaj
zqe*lfWQJ<<1e_h3AN|aQW(|s6v!*41bx0>Q!g)Yc$^?qc+iEeby4Ri14k{}b2QT`}
z&VcC6V=h{8;9wiG2jMahtn5Rfr{I5hB)N#E<08HlnARHB7w{5k0*Q+*1s6Z-RKx_k
z^Ca#z6Z<Oe+EfP5$^mT}(9V21ir4B=AufpK%(x2Y^sCN{h7e?}E<LRuY&f%f5Odap
zvsc43g-fRsJ8l<b+}~=`43-ikCa}$p7=#0iuwUPr0Uav<5w6ilFI3xj%Haz+knteG
zCL45YJZ<aAk7g?MJ;iP<>#Z58!)pYtQ*7?lSc5@?UA`512H1|BavNk*i&mRd2EVuo
zy8bzX`-MW#r=KpCzWHd%wl?ML<BRoKy88VHJK+ovOLb^TJHLp1zzJzN0@`auO*&mx
zaEIf_o4ZATLr<{t`a1Uk@x$$GsV!_dDK_`4M5TbU`N33w1EYR~twTe0GdK{7({~Xw
z2gf&gRmSE3ddgP2I+csR69Watvz10w2-_T$$sj^=;x6f&%ASSvnwr_q@zO!Su|@2m
zzuaBkIy(W8^&*BesB&p2a1MD)$%T$S78y~+$6mM6>kN^mqG!RWXRPYq=O~TTvk#sd
zw@rBeu?R5Yx4I=FJ+lx-73L^4Y_1kBZ9t%~;f9s1mI9I99E*{9<&{Sqx_=k3Vwyc_
z&M{FI|2a!qtrfMzavUq1Ti*b4;8tRL2mx-LjRKGGARU`!?ql$}KhY+G!PYq{r$#56
z?DKYbL6ANpTI>Auc3Z0d?tl^mA|Jvhs;vKjhAj}XqHA$c=)9CMsa}t*Ryvo237V96
zb5-A}8t5)cJ%_df-^7RCpb#u%P)Qq0d$_q$ay(9nm$x=)+5#q#fmy*=Han<@^j~>V
zptfypw+z(@xfew@Pf2`H!N1z8f;zthD%y@M$2{P|7VT{Tnzkjv9<LJi1xBRH1hTpD
zOThZp#v&z4+vY|8${)M?=jbaFh-gX}uZ-pFFAXM|LdQ>p=ju#1Ir;4NZD+43Q8AJD
zAa&+{3)u>;QYR<8n0uEs!fqPMxAFeE#PhCa3fsd{Y1dNd-Iy7e-|m=D{^Y}w=Jqd+
z&42)cX3;(T26Z|VZI+3BXnpYd`7a;*OCD3r0zETBe<OW_><e6oh-$O;*)$Ovd|}|x
zM`=inx$)L_`6yGB+k~-LBasYpJQ|~grN;u-*Ii(X7MTEc2Rj2iqkLFZq1mEKjG_cT
zoNdm!X!Y%YL5?+4XnX^5?c8+#bDL+%ozBB;fjyI6kgD4TG8lUm?6-toVuI#^ZMI#<
z0(QH%1Bj9~e#tk}`FE>7?9pLfOkV8iGO!Vm0zUma{mm<dy}~8UofWkpDAPrA7#?p5
za%pY;P@~V1_+MKRs0>#8M4?gaI*p_t-ZRJs8LC-ElXb^?cp9PZf;h=}=upHIoN<Kn
z0KPM8>`={}F1MD92#63=hrA&Tnb2)r?_Bs+{N|-M=$X~?VX}>ty*U_H9$3lY`n!9E
zJX?nnpJaaHPjY-3L1Db9B{lNXvuJ|;^3^}uW|tfSTekRIXRk<vaazRbcs63-k|1cp
z`jvRmix^$gp0;2QlaNb>9S9k}W6^JpyV5XP9qP7;6M8QxfG0M{Ra%WzI_)OSp`MA*
zsw#cI2R5{AtZc`t#a>^V1J(ye)&o0sPB+bePt1w{$k|^Yimt_A_y$Vbfj5^r9VCkm
zJ6VoBZ98t_lkJ6R2Il-}+4HE)R+t@;bNFOso6S^BNJANl0j^Dy91c+0^;kx1Ord@H
zA4TUL*5d#F@%!F+wc0wUwQ7gXC0Pe_ZXMLp!HTGat)fVM79o{vYpu~~9k3FXQX!0@
za{6wS&KN=x)&WTvLWq9*{eNHAeP8#r_kHhvzMhZAo25D58D8pULF>@3$5_t4rqBxs
z(tZ&0pLZN2!(@fk>%9Eouiluh$rxRe!Svu(!<wnC1X|vy&HgYx2cqH_FUZY3Aw-o7
zD*=#fAbK8VcA^V$pK;=Vi3`3f;7=DnYSpa>sG&YLrMJr#2dq#3nnM=4x%xXLLsv9u
zKr1_sZH781c`HM&HD}87$f%035_gxpMwQ&pkya4eWsmBbPWN9@L!r#&d4(?JWi0wT
zyS7}iYcYxJTIQP9i0|r&*SDt?wtnkO8}1^w9zjisd(-orY`R=s{Pn~gS*~DTsNV<7
zjJHjf%b35X$QQiTvZd0`E7X6v65=8fx{bx*XQAFyw0CoxQ_XWh!mtYm=`zG~tk0|P
zlKZ~sKG$$-nONX6*ZFqluEmgvcQ-UIJa1(YZ;6htS8|tQH_s^pdcIg5)aYxY*K>8^
zu%pQ&yqnW7*0o}ur@lfro30SUo$7xUj#Ix+C+OU&y}JzNziMtZ9yX|c(Rxhfx#7EP
zQF;61t1j0AButkh^}4&#kE(*02He-uH}$aSvU7!=nuFl)t)}9=9GVv|I+hNKVBmyt
zSC^eX6_!V(`(Bx(U-kXL$NM>__%FY;c9jiubIZw##?Vz`c|P;LQq1uFVW^9eH}$j2
z1!e}P`MQ&ZUU7L&u3fGee+*S-H4kx+LU*F_mSg<M3&WxX<DUtH<W`zJEN^-9Eob2(
zbvW#ig)DdePTvP37yI><1p%HG&}#`uBaw_h=6CVCB_-6D#^|dZI_<TyJuS@n-BK>H
z080t1v?=42G8ewyUDpu0`A&|rpKGW*?X>y>XX2Oh+dK#_?1$=_yOIK)$oy4FVMnjt
z>b<8cKCI;#cDN9utpmIHF5+ZM;<HOSJ6+4pBVkj&(|0}`Ut|ejJsRO%Pwcn&r0O~)
zW~T2Xd1v1*Deii9dEjB)<nOc2PcLlp&V8l`-P<R@+)OF3SRZvuoc>I+l;ZC_L-9`>
z+~Fl;zPa$s>!5=7i*UUs0C9YFzW7m<M7!hQfJU6OefiegiS4bwwwd$3=BNLeaocpZ
z=%i0lfbOdBh=ED3q_(D)-&O^8C&F50zpqCwGrE>iq03M_#%^t6wl=+a@l3cMVRk*s
zckoluacNkPO(K(d;q~p5_RR4HixuVH$oXSmJAzIW_e3<H(Ri_dlr5>+hTrqM1EGPk
z`wBNNu5|1*ClGG{TG>A$f{Zk8J`|L|ZcUv1UtZR@fV5AsXv1*SkZ=SiJLb}Ru$IXZ
zCFHP^sP1&uf($rg>S^3~oaH{zTcvedcYDvKoc99K-a8^C&%CGq9RX!hPQI-kf!jb)
zHIDZWPuaM3;)_Ot1+E8Y9c!=nfLiMnz85=j75Y}+0G?gL`(6_t6uY0a`%@;FuW5yY
zU_5mXOkwTgk|i)rKh*mNuutsu8XDx^WZeffzW@+%<9)AqB^KX6+KJlHa5^*4Rtfdh
zVZ1$c(8Yz!g>FHaaa}Gwzm^ZfF?lC*T6avNONlmQVy>EaiVY2*Np$use7U<6s@?BU
z1*MX^Pp82YtWG<Frl8X<-Xd9P=8xL9C>U&!ifE_f=uEBD-`s|LI8MSdJ$UJ1KSifi
z9z@#aKm)kYA|~ab&vI7)bRlH{%%rEZpSm#il>$;|#u=uDjRxJ7>z{j@4`Mq<dWjWY
zg<YIjLmdh?c;tP-F-=_?rLKNn)j3CPgL6rw<Ye+lRr!KggBv{a>#7c<DW7(@HL|IT
z6Qk$qyES2VJHT`484ogc*o`Qxrsi(pU`r(r-9XEEX-e6wgf-5A;ltme(7LKR<3r_W
z78m+TVOU+2IonGNCH{0RU_p-pplSJd0ijio?!e#TlIzb)J1Vz6?MWz?6`E_%IirjP
z$D}g2P2JNi*{5*cTyyh9KiZOu##adE!WN7gOO$#)SWY@t4{uj#;6#8wizgv-S5v3*
zV`0(n3r>bKOgNr|W!wG*EHe|xT=3F(X&8;n>hGs%>=V)84pg{yFwo6tMJ(p`a?9ui
zKHI<C*)->GS`iJvc~ng9u(`p&4Vu?i-(o$_Dd?adbOVHYtAH%gQ-?m(%A)`(v{t*>
zY&gJ9x5)CYS?0QtUN5SSuEvPpc5b^VD5!Ph`$~fTxgsEQEvQ5Fd01Q@@L_&^KGIVO
z49j}GHoW2DEZz{aminu-$vkr!ma(yaU<0un@E)GQe}3G3nSKShCVfNfqT?|PmqNTa
z5bu<-=nrCW$h1Tos!lDZpYg*#%-sUIGFoY!z%Yg7?&dD7@4tE{%69zM|5I^-B`k?|
zI2)(?prwzW_N5&@Hbn?LAhVr$SQ^aafUx%bBzKl$kA1Iszr+M=tu0MY9tY`iZJ!%D
z$W~J_G>9Y9lgP1qa4Zm`q-`BxRZba^aTYuBuHxDCuv=V~f(mwDm4(2>Gc;lZ0^zxj
zV=iUxm{AohbH!Z?meBFYX+`;V9Zy@6biJm$I9{iS3TwTHp1Ij&k#No4soS44%y=8`
zzyw?@@=Si0pI&-i0UbWukA9{=u4;Y<YS0pFJ!mvg{IqnbFO7YCT_9@l*fqoh)))9$
zK>I(Zx)rfQ%tX{YOy<J6?QS%=QN9K+vT{MYr<FHvdtw2><Tn-A?<D+V1Zu}lptQ53
z>kY&-s6GH&wJ?r7EX&hiFzjfxYofd}gcm%as8=RR!U6}OuUl~;mtD8v`#fKYh-zN>
zmUX(urP$Kbsdxp>4_7u%@DR0K%nrR^A3_CI{H{HM$II|Uoj_9*C=3hGBp`&(619|k
z9S0fgnHe9o5M|&KCtF&^2=ehBzY>o7q*Z^C@7#SZwCLm&c!tT+n5gU5aIXHOw`|C=
z#6aip9wjP91trHv7;kj3NdBUvp-P^tNLAJ8m81xQ*y)Q%zxi6dQCSVR{XD+;XsT9F
zu*|AjK&=-QlX}UVbDp#yH@jM`!sH|okGblWsXoH8>u%zKcU*Y#LzCU}RsIf4+1-x`
zIzqdIuB+;Yh4PGbzYt1+q#q94+y%I&`gyCyi_Bo-h@+HB*f9y_*~#_AGqNBr6Ho}g
zIAhNhuTir#Fo$_LR<1yLxKp|?B$i)n(;9>UP3w@_DO1%tU~!DENq~*R1G7-`E<FWz
zNBfM{iezABdLVro1{SpUQ=5Ct_e`6cB4w&*qYtGK^~`3RqRWv-DPoky;%|wdbAB>V
z{|R^=>qeuFO`rmUAo)?y+Dm<MZtJ3yW@IFvjD5kW#rsXU|7#cEx74t@s#ge0vLJ}W
z3UVAD1{v!s@NyV00B?3mmVe`b+tnRlvJ4e>8v#Cz!{#*QVY$F=svt7IyE($P(-WAX
z`r9`r=P#wZ-Szt9c%;gLsjWBI4}WUr;$*TKV&N57G1!hx&E$d<8ydA}b8t(VXP6ZC
zy*J1Uvz|r)cLOW>d|qjK%x#L;1`XI@7SGu-n`in&v(xeI5NBX4(v-T&*J<ogA}r3_
z_q4K$vzF_yacaHe&`__A3Euf&Q*HGIdALtFH)dcuNh@R=VLFy7Ovr>G4rg)9>1UAg
z=r?-A^qx|<<6(A5-C_%3;GS2gjH`P<3EaMqTn?K>hU24+5SdMG8}@RE>U6bTYO^!V
z7dpL-?31%GKdAblU~J&v)zGb>A$X~9hqSKva`0<^8<oIvvtQ8L$Gt8&Y%Uf@yYKHM
zTb6aEXhy@Y&j_*^XOpE*HyK2R&#ZxLano96k$s_JGX$R5-Po93^ZUtVjo3fwO##c+
z+;6w}3W1cBg;|g-&UVs}`l5|@?0Cqfc;9o>W_+hv?sMUjUhNV-kUX0}SSOsN{;0M7
z!8M*CKZl%+R#Au(%#Y1HJ*pXLSD!!>YT9b)8?FSa-=ei?eryU-gJzTrg_z?=KjcQr
ze4JWfvB;SOLzTHU6nOasl0s6A2edHF`rdE#iBw2-r*-SnRX2Q*fr80SO+p$6qsZ45
zCvVSyK&~oN<|#n-8R8f+c?|^W2dvIwPX7Q6l4U@HFUduK45k|4W_Ml{kebMjc&1hl
z%iVtauGw*78h5}3iukuo!&3GA?R45Jwob+b5a&zklMkvF_!{|$2FK2cnLb||hEt}f
z-3}R{cs~&)WT#akl+YtGDH%t_D*Mmu8Za}1F_JNsY=_PsD3OC{V3Fpe))V9Ul{-R5
zo9%P~z3R8Prcl<IbIV#;2GJ6(gH_HPtE|}!(+FPGmNAF8Sdle2Dhph!lt0SQ&}iO8
zn6)=^N_{*ngfKZ5vf@ovtB57zcOz4u#D*1XlZ}3GO=cvN=&q0wd97a)>4tn~q)cD8
z9zKDE@Gg=BT0OBeJT*z@BKEs|r#(g)nWGHiQ!MbxSjH9Ww`X+msk&(s1}KU41W3B1
z{`Qxd2QVNn=&y!tY%dMr@YI$cVTo~ChLHhJJvrbVC1JkwgzhC`A_{tgm5?P#JhR$J
zOuovWCOnc@>NznSl;~j!K%v@w=e{-Zh47QHXLU)HwKTHq4O82Uk#D>J8lspwX`O~H
zUycpQ<3pMH8P>?qI<;O6^NaQVAHPaf3on5{2(|W$PbD*#CW+FEhOd>n=2Tx*?QA6C
z;}74DWIx<~74;kU6Y<RHb{1mpljF|^=6$Lam<Pxlu-&E(N!}gp&Or~Hxo<V`!)zVo
z8`y|=1F@k&Y5<M@UCI?P7jM+|k<X0J$qo6U&xE@_Jo(Ppig*`C)NX&{jE{tYJXFtl
z$?tL9-8(NVa0y3>AT?y-r&_~fskZW#X6f2LPtR*i?K0dBS<n^fiID&Nl(0+yGk@gr
z1{%l){t*)XJrd?`u_WE<wUgA=p9jKr=dYZgh#STccUl~eSdwmlS{Q{L%{Swc+(;t#
zTjpYvyM5DaEu1PPxiI`P<<KijiA|vY;_?gv69jWZjJ0X-4_x@_Ze6Bo>pTmwBwrIU
zt*@;FCK`!$bAI`A_+d=KR~8|eiCT3Dbyx=cC?!b7HzmJ?1kg5qq7dzdi)Oi$W-75J
zK(m8tkSqZ#_@?3O=_k2_^7m^Ec9EJmQDhFLTi4urh&aOvGoOG?1LiX<6Nk!rSYWp_
zUWd>bG&neDBSGfKM?6a_41!1^@?zfyLOZQD10E7FY}CLtw0{eUl^M;-i2)+RVcWfd
z59`;Y+YW&Qg+8GP^jofk)ztc6x{QPl#Q0i+=R?G?B0C(15LbXPtF-D=5`b{8nQ>hP
zLh-4#zx>O0@s+)cH@MoOMuhR85#cN0;!xH3GsbQgm-<O$O{}>7y>X4TIyp9`Ke<oH
zW-yGzXs$tPDqTzPNaZIawaeopnR=d`BnpI_A9l||i9($r7@NO_oqc{u{wQ%WNZ@Ps
zU%W@`QNkz5{t}7N*b%^t6*&rowYDs~Q5&`5TG;eGYm+?{vqC-QBZ{`faK09241u)M
z{F;2NpYu%5YeSpw8O^)}@Ne~E-T;1jwnwivd(&W|eGDfiqI#S#a5V1nIKEQ}I`|r&
zIu_SR(RFHhGe7>OvK7GS60(^33%<r=m#(zKPEUloE(nLqexzX*!RaUg_1&SWi`X;(
zwcubEk4$O-dkj=u(-LblU9$G?JY%P$QU2+UkJCPCGYyVe&?AQNu)5O?TzGWJHp}h+
z=e>mWleGr>Tuk>xyUNV}a5Xb5tjyc?<ku!!PuN6~;R9r&tCPg?UEwAWa*&O|`A-x=
z8p-Ul%}T|ZnIWJRM)znl%$VRf_>xrNu&a6cbCJ%@>O}q0uLg=oTZ@OGi|6fCE!0H4
z4I3hcT1ae)7nA~eu|RtnL~R$4GQGb57(Nr?4*0CKj2fb7&Rq6cT(=0>u7O&=ahR)Z
z#UlNn7|n_t33I;Y!<K1@y4oD5<TB5c=kMhLE!ZF6!}#wh0NUYym++ws#p*@Y`oM48
zzyy)j`5mXaBUj*<`ggi@Ozil_@6kH~gYTV3oxF=ZRc>5AoUnyQ;@1MGWUWiZAs;@3
z{A6jSM~0r9Ti!|bw2KY}w#lb?QFsov57f4vUGt?ipoA8{2!Yrz!CWWC=j{y5qf4}x
z1iAv*t>c@@rXtLr*jZhR%r_wY0{E#T<qjO|RF}DsR<Hy*P>+dv@!hHtMEK*E`6+>2
zwZ&IIl^ghyX5>pU_WHGR?C><4gV4~Z4BP_f)vT*-fGAY*7#*5XRRmsn40q;>cJAcn
zN|f<E$Gs$H&Mil?_)rMPP0W4%z{CvZ1g!qVH2rm7eI$0O47)hQA{EJrd(RrreK)vt
zZ!32h^CkqEC3p2!-dy7dkLAEaZ5jH<SR`E%@w%1uJ)<m+|9RI4ZD7g3O5Ju157sQ|
zz72k=;|S?Y;=S7VehpAHp%=|5(dHQ3-=&*z1_7VigE;(l_tVkp+9d800>Y(SOP3nA
zvBHLoF_Y^|D-qpQj@#FX^E<xg#+)taczow>ie=~d+4Xo-Cx$h9?2)e^RJH{FAoUt6
zMZ`H$`{2k&gZ{4u5S#H${~lF8{fHahMb&5_ZjhJyyPDm<lur7lZvw}qW<LLoCNP;P
zG5a=L=3<&-`Fk~7?!{X<aa^7sh<4&2ss&hgTCm{_(qbPM_lWQtvKl7j7!1qJR`4`o
z{S+Gss@;xc=?Agu!K+F?GY5YpCYmfrE^93v{Zy;(Aa~~J+J94OnU0pL8*f)PHeP?`
z@xT4o4)sZX`R>LP{#gLMqU;Y&vJN`uubUsxk}3~cOJGit1@%NdcbhH-cV*$54In1K
z#Gf<r3GFgis|7KX#a&XzeQ<0<fF<$9>%D=!)OmmZN>bo3z#AX6D9X3V<G=XL4`T+V
zwA!m1nxT36cPy)Ll9tb);Vln2+cj9PydcC1v$ue>#p-ggHQ^UCxN=^@3kW?eMrbo<
zXF%Lj2RS}LK3}VYgM;zDDUY&u$;1PTHZ-)Z1>WiLswb{mBjV3vBPO>(?=q;wp3;2P
zy%Ni#@pE{C`!+XXE#<0W=qqLPS7ps2tStD-=8LH&%BxYseLxB8s@=X~s+=_8TXA<@
zNZ{J7WRq@Cv;^O!sNH%~jp&kqqcP8qMj<`seD$2Z7Uk5oWCob-?$}fZKX{|fvB=G1
z{q^(pX{|bdUcDCobA)LTrz4(8_{ueHb=wc!O^$iG<Vb;Ks;5~v$9P7*vStb6(Q}IF
zu~A{TsYLQm_6Rp3C$`E>K2h$ono;f(guu5qq3*UhJW0gUkV-iUQz)3*W`MYl-SzW`
z6(PygFX<aM$)m?;X9BpXzj<**$z;7_(@(h?9J+Q60s$KI^_|TSD{CgkUqqQVF6Wtw
zl{Vo3!RbuD0qx=QTFfk_%dqSHFf&?LiQi=ybn(-<x*JvxX)kNWI~_eQ81MNQ2T{(b
zdMRejz17CW;{)2`ojNBjZeE`;Im)GX8f9$0{rppr^wuNey6^_y{hmByGYYKeGX<~I
zny=q$d~<m_tHkptORy&EJ_@OGsv<+?wy8UGA2U%~nbJ4DnttL!_$H5zb=NL>y*Ew(
zg_np8>KM`R`u(=+PxgarI7nTJ&Lwr=DuJxAY)7Bf+S|x>1!l_r96H_FVOdD%Rsxc3
zS38-;hR~bl>mk)Z!eR#(!-PRIBzh|;j-8wGR=Xf|Wr#OZpsNzBr!9#tza5qdf9;V!
z`Ddt;3AzFVRoVU~oA664%#S-rZ%{Am=l`^fZUG2_U$Z2uQ|8m7->onpBDKzR5D8-;
zq+5r(DiQjK<rc^<B#!0=){=*et&czrd-(NMdDj12iJkZ>Wq{QsiVu~e7jhmObBi?d
zl)=i`a{8+AF&e~GZHxo;^{qWVx$5pUf#5lsQ_YJ85-5?0UPIB%4P40vzYN}K`N`EP
zy5$J?b?R<gXrib%IF>N@=iI@aa;`sw)*_+1l0#qL4nyLA__pPzF65z>o5%~Wu>sl?
z-8Hnug!`}0VvKaHa#Y*(AlkYa^Ao)e^e~+Y#;c~o%<4Nk42&clZ!bSDgL{{JH{Ndz
z`e`tRUwT-{8%ChR^Hu9w$Y(~b?ea<#9{(JR#hC2OVh`Ngdi7jD<*&&=YcQYOHUDyt
zfE<9Y?2oi45<ZUep?SEG0~9vI|LyQ5G8K+!J=h7WnKy$$7kl%sr`pb=o_-$X;tX@7
zU8|bk<gfldf4ACqmHcE(Twu0D)P?uS`Q4t5{$S8!TU@rmTR3IcJA*^<-Z&=(E&cEX
ztrIu65gP_Mw!ee%4f(Mja{BKu7%v*Xd+y*Yk=!i{^S+n-Q{5<?GcUrz$97|Vo;3w6
zZsDg`DtcD@nfAX=nF#J<6`*}3CEla@6cA}zba&AEmkJuDtzS7e>iv_}LPM?_t0;AH
zN+fehvvXY`SW7D@!hQ!;#?m-j)1!qsUDbkJv6faKv!8F;(+7#)tny#}SK8GJ)yZe~
z+ggvzam>l@uhb&d?US%wta?i>wl3}~2aP%_3G-ISm{nnz`iEgY114W+NNn=B2ATIu
z8R9c)qTGOO)A|Pbp<VMHcptBk$)U+Lx(FC<Jy`5B%)W987Et7eF4u9AAuGS5pm2Cq
zS{2k`<2B~-Fhk|;2j2VnY#H^3Y7(R0u-mcN=W${g4XJAqF<@~ui?+xk|CZFRwMfdH
zUcKsHQRMMxeG^uw&tp8hM(@km<H17WtHS^8{5H$j>`AziP+He`r%m&$CXBb%^OU^=
zz|vf#JV=#*mL4)6$>??*eBPzK>fb@NsLY!T535{PbZnQ;uux8eluflfaKXWhDUgAw
z$6ACJR+SucttVagTwabi*KJrkm9SP5yD;AkK2~)V7NX`l<2;`+67G9_SM3Ine0r8l
z_s?)equa0Oa=%jcn}lob^K;G`!D=toTCdSi=Mt|Uu634vW^-;@7?;mCpF+RPLc?$u
z+%B5=94Cta(&TKy1J`Hb4Q<O~^L2C)#F3V@*tZ|`)Qws)dlBQkYwO1-uLhAm1$paa
z&;1o`-=V>;iDVhW^Q3G`r1t%sLG2Z7Z|blsg5m%<VQQ{LxB)3WQ|iVQ_5$R;l18l+
zTijY=5rrdlSltU0>cWb<AMdPr^0IVKsaKat_mVfh6?qA(+%Uvi8qCPT;0Szr&9HQ{
z_sA8&F<&#&ACD1l10Xj?<NVE!ItQ5qu#J*TR9YTOA6Wiot@u1XNxf=zBtmpXzk&Y-
z=wXz(Un<iU+vY`XdOxsH(sk_9h+6xowjCzx<UPr>fhrg$y@qN_0_!DKNQS`s>leSh
zvRQnKQ79`jxg=#4M_Q(=a%`0sH%F~Co{~jH;}}OiF2>y3_X8JrV$B}H&Uu>9WVhC?
zM1SKK%AR;^yI^KGLiR%1g*Eo0S<i#c$qF3Bgv`_b%qrQDY)+gf7wB&3HvP<L4Ex2S
zSuE_ua&{!|zsZRBI3%yx!LalB^Zvmh$Q0%yJIHp|3Bw^`cW~#9^L~Z{42Qjkm!sJl
zJLokqY36p+?l?NWusMvno?mKTZAEgY_dz7SHz7Bc5k<hO%*qUc&6d3KzYM6h4y|zM
zwjIlKZT!9FB06@k>xe(w5t@qnhJ(^zdsKV(gHOlWvRxAVbH3_Hp7J=XCI^1Zg&=#J
zvYH-tKJxhJQKT;JOmbwNv1n-EllzwkJ4F7A{|%_NZ?eD%5^(VdE9nS-l!?u$oU3P_
zvtHOR-29NN)c>TnW1$4RsXYq>**upY)_oLk{f+N_bj-$^ua;as@I+I*{^HI%Hj*P<
zAG=7!blEvc=L)R75~rFCfP}Kuo>VeazitLDVO%|^>LSL1Ro*`wdtZk6Z;PT;IWD9Z
zJ5iMo3OnCtuB>SF(<1Ve;(2W5`T{?%FPFZ|cMols))-hwi2p>8n1zR$AJsIwc>dvz
zIeBRs&J4s#@_cTj1D0wpDFz36%yX|3Z|mjm{}@C~V=gDYA3sp>25WuY5|Y+EgjlGX
zfzCd}CgWKv(5Tg(zaL^x=8(b4#ptJ-KeBG+z|29b_d#BsKUY57QAcW}nwAFE8XfFA
zP8uC)<R>=XNT()|)GkMym$3D<*ALW7WkJr*bgegA5)R<#dG76Yw_{ZPrWaPz5djL+
z=YgNZ8q{mbhKyjW2|0Y`+k<5DbV+};rEY93P481|+&+A5$CM7;8Ayr5wvvsg*%RJB
z9yUuYm`k+I%({Md)cg;@CG0=?L2Z-P-CeU3p3#bi*gP!N{4OTAF32n#GAdt2_-|W}
z3PBhsH1S)f@$1v<^hav3+whIcaI)22xwEDI<5GWX<#6dAN6p6_mY`9GB45DbJ&AU-
zV2rYj<Bk9}e={E~Jn2~^wC)CVL=X~UON1xEF$v43?fu;j*GwL(ezuSwdF?=>qi#7D
zi>h1az5U^Dm%9bfmy-romVW(5E?^UqkrcdIVlf-yimvgy@K4<B>m&lAnwxs>Gkxdh
zpnlT~j>*tK3WCUX&eiYs8^$$9?eEu`J>P{3^=d2dmK4RO?loK`F)!thW4Bs$R~6k+
zw9PReV%UJ;tNa*Wlcf~)(*%>RtCv}o1kY}oHYW<^-@vc3i^E@kC$_Ug{qU;(Tot#%
z^D8vHtoL--PzU^_@VVyvs?oLG&y-_$x81xeGiyxm<MH<W<%f!HO}h^+(<Sp0<3kT`
zz4``fKYd`6!=i#0IiFw>Bz+d^AcKp>j+#EpM=S|+9u2IoBiU_0TCA+(8qxAd5xQ~f
z4vUV*L}xF{a}%7`R)89w+?+eo8#foVGuv8a$N;jRPRS04sXhy_LOl=?D)ZK<$(|)C
zheOamL4y7r6*ub^*8UjR7{@|-Jpi<hi1Hq_Nl*bO=K{aAeB$)sWrk0=`eu%W^u$`^
zX8jdYwt<;?iDYDeSboV#0WoE>^e&P4`We!0OpOHPCEPo%<2Ro@BUY_qL#(YR`LDXv
z+*SL*Pc2gDN9%fIowcvhpP6ZD@;|tb&8;cZLws6ICw4_U_{ZooNW#HRzXN?~u$0w{
zIaKN)cO2rRL~VC~D++dk!;t*_(6uUb87?=z473Lh;Mxq_IEb@s^lAyzgPL`-9OA`*
zh3K1JdB;Ov;W4D>3o@jaBzFlO)@z-$O0vP=7{px!KaSHZB*Rycb4fH<5F34+gHEP#
zewjh4+o1REg3b!)e-e$;Dnt+t+PfbTu0S=?kj@e)e?KF>7J4EGcKbN+WgqrGC8@O+
z;w6EfrfJ@=PDa<}^|lFCDKks}s5=|Ek`4uu^~`9QE;OPM0OcoTx-cV%onUp_f#u8y
zLjbx$hP=R5lk-q+{OY-FkQAjxx>DT~Wr_L(`Olz^)0rNUMfgd!Mmlit@CfRB9yW-|
zP5lBoGGI|c9El@vcq4R|A{wb0`=u}!Wky;$WcD32&5%~zi@YL5Co^DMQ7O(0m^Utu
zpO+)b%-qM#>6_Nz(x5IhXDV<2tpn-a4>iaKouvoRRLp_5(A=P?lHOeENFleE>nIaA
zvk%~ajsJl4@`=y|s<t%;afyZuP!$o$LU#_Lj;(P(3A;Z+Q6^$ni{RKy*!g7Ea^S!?
zp5`t()WSw5&|u4@2DY?JyMFrNq}&_(3srr&PlgTN;SnqFD4l5@Nm=})0B0o?rlj+7
zl^VyX@GxYGwFIgb1z%C3qNGsb&&8~%GT=WTNg+x=e*rxti1TdZl^~eAGNWWaG=_b&
zm<nGdJ9_3Vn9_c1K`l|^V9nnZHnyqnC`7ah3fUq4bPP0<hz)V}hl8Du#ONJEW*+Vk
zOB=*1$Hn4)adk(P|8P~aTx_d?lzgc={vK?osyg-_JcHiW8E@DWQ!VO;JnS{7b*pZ4
zb3JF2DeA8}9jtf87E*NXL<9PSONE#ygDfXQT+)|U2J5x-*O>I3@afN3AE<Zwy}_Ns
zC;z<795{C}s^P?+>(zBer>?)pgKore+mj>}#9jqH+`)SJ3oLRw`KUv@j|)T!G{5%{
zdaG*Q?KoXsb)xF+$$L?Yr~h_{U%apSX?xO)AqiWJpW6#qa1KXpXQ8Vl&?7ZV2=){O
zgiw!dVOCr&IEk!28Tu?k)nDauOsqX~>czQJ6XM$H{!>qlB**$i3>k=0cX(B>&kr>d
z(4qGapDH*|i`mJ-l7TuAc3z=z<cVmK1CRiyJUH8sb7nB6KKrUga0My$ceK?2_hoQ3
zHK}@SP(!=zNxkXQ0|#nc?d&y1&rJ3Eygk>j;V4k7#LjTolKxYJwhh-0Kpbak5^A;n
zkueTDN$ELB;7n7AT~(>wxnF*In?_IDonJ2g9bN5y&Oh;7ao@Rnzs{Z58C5%Tu4%)$
z@}1`!2oysJEK0dpp;La|fArj6`hK1BS`RivRS&59uSq{?u=DQcTURx6d(TgDfqsDA
z187k?!~9||JXBK?N?1EJ_z@45{Z#Z)VhJ8-P6f+(-!5Ktza)um7ROwYRG)h99^lM?
zhfp1^+EH3&D27s46dQWn`r@B~%YSDsFKS4^rBY~!6bJ!z*_YrR=RTBU)*&x$I0|VY
zV+7R08Yx#~8Nhu7R@fT#LyDfwy7H$S$R!(H-ixf=SM96XI72-vsDfN!GKcY3om0e~
zouvy|QiC-u9)m4jA6k4gTYZ<d`g=&P^uQZwsO;@x4;6H8a4Rk4at1@AN1@4Oz#Z8w
zYYP{bS7)M5%aCiSO(|c%D7Hp{q?NM~R!2p*G+s;naQ#2cw)CZKdqUdwrnJ#E>9zf8
ziqC3;E(P^f5MMQD__$4XH)zXDMTInHWs41E?fIG=WlK9MLOPD7bQ~}2;6HAv%5F2H
zfhSTr{&OcvKBUzTb~F~=xX}urWH)fDFPzi7d1dL%mXMp*Qf{^t-t5@aVT40BDm5-J
zH6s~UOw2$O6F`!|-U}Hzeqc`u@Zbc{^#R1OfhQMQZWP{re&P0u!P_rC+<vWj=aC&a
zC2^nAN1MA7^;=+<B$)ev);%`nKM`<R0}N1V+~@pn0Eb?4LM^&O+!kRv8L(%@i+A9=
zWXK{Jx>=?<BwL#ewlOiCz~&R=1E!DY{Y>mXiTs}wJ4QthKBpM&L(fa)=R4OMDiEE@
zAiGFAt=Z1y>W-Ctmvd;BOATa|3`}T5PY)9CWH=erlCU*ab&+mmR--OljxPiFJmyg;
zx<#q!;SV#~AKmx3b4AhJnC82ihVE{jy{jDxBFRQ#Sy!qYbZ4VaDq~Pm*ge^fiTJEF
zA^=5`-PA*Goj}0=w=kM>j1oIb(|oMJwf(r8zpJmHsPAxdU*Qm;>?t;J;hd4|Mh^vK
zC~$Hd^j;lCjze290SwM&WmzMIi+<41>c-YAV*_n8Z~o9?-(}3;75l-K(81OZeIiU~
z0K@)-2!fL#EljXo3iM8ndPyhYfMqArA<wcwQ#o*l=Djg)@Nww9C%f)FE4pWpJ-BU%
zf)-&;Lg0rFz*=cqMkdB>3RDo_28sc13Fhq^4Y)$Ld@KzI-1|+w_q_SRpP>hTXCExq
z_$LhA`&)-}$_UkG0Fi8seo5RvCU$^>PE@HE1++zKPvatxUm#^lq)WnshecO`Wsl6m
z9$BV7a=CTy-5M~Fsr{R(?akC9(Qc!ph&Bbr=Mnb45{48Nepg_gDX=fuFtmEOesJh#
z%>(O;!y)&E!#)mQIq|463yh*^EsP^~MJ(RJ;b43wrQ8o;!r3E~BR%RdcmS@qZ<zdd
zIOX2c)Q?a9^J*>0K|}v$FeF!IX=r{53q!m3p8{>vi~S<eYF0pY%CzP=ng|@Ujk>Xp
zhWgFc+EM&~qV?=(>ht5p&#MlmmBeW*KB);3Vczc5sHuc(Wupig(UVlIIvmv07xjgS
zZDj+oe_d?3Be_2xR$P33^WKZwA79)q1}e-qYm%*qk+4p{uZ0O<Wn;_zz&M;9_nub2
z3f_E^5MGw9P&cVKz_HyMXUMtwD)q9`oLUD*sQ~n!7a#7u`uOoxVNO^W0UgUhxHEb?
z{nQt^X&8VfD_<uAa5G>L<Z%Lq*=Q5at<G}D?^LWDfJbr=ol=u$N;gz3ED?w3SKx|q
zh(uY*XRQf}!-RQmpS}WtIlk?m5;d5jr_VOmD%d<?xy+jkuA^x(0JnQbfwfo6M6LEK
zR-nfxF$>Zw-=1LqDUVxRnhLo;6_zU#r)zm9V)+&nyb3ld(SFYfpjT?oNH9U^AkUFV
zk^*a$n7EDDS&7zJ+?z?}_8z8o>?Q5E``Wu@6X7NA4qSSd9o}*G#f=+Zvo0>3Zua=!
z_alH28Oc{dQ3|K#LFc@G?{Xa8SA@SmdPinNQ^SC-j@^HM^3(g%+B3BdGj-uJXVYdH
zOJ>epnz?X)apvNunakQAt~h*X3IC9Bq8pR*;o2)o2a$H;(}(~4YtmH$4QHNlgFu{Y
z499*wl`cJz+g9~y7C5M8MQ5F}!G3KpX3%`(&ijYjv#+&h45^v}v`-2eVkPUqtxpuR
z6g_nbqrjm)A6{<6)ac?MmY_Ry+1EGihMvaV`jd8ZrE#m`ZB%mvxr>cj&iE*{2GQiV
z?^f#cD=;5DG&-&AeaV<lmoUDP<@(fKT@gf7aZPvP3t9?jlJSpTsI;-4maU!81(FEk
zwvOUY>sK2XKC-=~eC|KB@(M#PIsrNY=wd*%5I^!;8a|Q@x>3;rg|ExaIR#C-izYKN
zUQ7yO%&oucF(%PkvONkf-`5A#T6nJ;rC@)lKzus|;Ze0_Wqa>FMqp3)XVJ92$o7uP
z;>EW36AG=DfYz%|U%8iujQ~`I67?*95L|!Yw;7nKm^(18DdR3TWxKYkc9(~Mk!;Jg
zoShg3QthKJBmb0Yf{7gG$8TCpI0z>*l*?O}p?Dq0uhe}=E&rq_T^YPWin<Sw0+joG
zU!y7&Xu=i5%zcB-hg!dJlXmgiCscEj<97b{_f5RjycYny!qk4;t<70J|8ngkYY_xX
zR=DgjJNj%xB>w9;-Cs+zQ-*U*wEwF$Q7&&|{}NwnpND|ji>lJ2i&JnM5w@sti_C@a
zVfvnQI>1uWG%&grA{Cn{#~9)K`czbCK8*4ENjAjSZ*?KuXKF`AK<#R-5q{+?>hasK
z8n?Zlh7PkQLc|2?Ez)@%kZ@@B2-S5*8H9l)rRY|QBFxsDf^G|c6U^;%IXJT`&68Su
z+Sw+$?mqv<^@~W2og_1H{iWCTuvkkRyo%GbuF24b{g)ljU3N$zycL!{A-t2F;+JSD
zW|n#FJ9(<vv0?4jHthQSX2QJ>PF*lxk1<+<dz^PVXW{qD!QPUk+r~Qfet!G%#n1ng
z@_elIma+Ntss5wOlU|Me+B1E_*^K%OyY2{v;+G6Oq;Yv@1D9lLpT(-(JrKphuWIgi
zEg!!njojq7GqU6<)UEsR{tv4W@+MlI;6+CKbV)>fRR9`>@>lXb!mH}@q5p1>3+#^w
z6ZCCLoK}}W{q&|e<|gUe^jvUEB?VEU?1Um_T;Vu9T{7joev<-%%bh{<HOWr~lqky*
z&ID?fw?+xBbZ5OOfo&+d)UK(WTvriIt%~RV5B6IkU$y3WcY#JiJnM*^+4}-h?{-w4
zW&tc7(69&)+9K=%gcTsEeVz;pS~Grz)5ac<AzjYf4_j%pj`W_27%rD_R&D_6fu!HQ
zAI@Tr1x!|~t*0u_Vj}0`HEiMK%p=PKY*d_t-yH(XqV4#f_&auiRfz=)FrJdG<1FE7
zRC&5Hk98Yp9^sjgE9~1e_qm!E8i>pNjB+Qw<ngd2Hj|t!sqQkd8eEL$A_IiA4H$2Z
zg`-Quxr;K}57&Nf$@%tV|JK|;-+yl9KoMg157Nisd4@9C<PqJ@rE5K2YBNf`e!|Yk
z3O0>YSsCq}VZ9^JIHQ;Uhd;l&rzUe0wXspNTG5b@JwbVgH`w``18i(%S#RGH*HLSS
za%CmeWK28^tSaf}!Yy^0jI4>Lt_3HM(Gqr`={5<gHz7$8tpjnHh$uLjqhbY_w*Hl_
zBf}aZ3To1a9wxlebQ1E7#Vf1=9JuLcxP-+$GaZe@J=N%m%O{p~Y=4(I^xhIxpxf@h
z>*~G07d7tjJN=FKR5DQDmZ1psjF~LqCG5O(xRKags{CVx`qVBkX6?3-U9NFJ`Bfbp
zag^8DH8@&tm;Lnpz{Pso(0-Jl*ESqpV$12AUe>_l8SlHru?1;8UwV(h+~ZeH7JK{?
z<0Ny_4aOvQKPG-p$qv7Z2^GucAf%cV*j3s@5ht(7lc{As4ueH<(0dqpOHi%=bjuRV
zL8&<oMfDA|pU7KfKMuPuB;Wr1!xtxD@Xak)=&(#b{jY`0XZ`p0(KzaMd8ZbWE#GfX
zChCj_#(&s>eNrMR%AJ}deqk0Y`pnf9L#GRT+Hi7YO<8GfjTvHdypc|gy!4=j)cuRd
zHw>dF%$zqTo}WZ|2l{d~X-b2@?jY}hhSJR0Jd*=oXd1t-G^C8=lV&-cNAOfcs>)yJ
z@u9$*9|2%JIhrr=NVkDwCEttdwA^+Xd-OfU1}Pk^aKZpDjsD`4u{=^wG)==<#Y>#d
zBh9c!cS$57EMBQUD-I*V`wQhLw#iE>GI2;wPphQ3n7Hz7E=WXBmpsy_iU1v8YuUf;
zGI`Qp;N)^n57k^t{3k=Ms$m_D?m=5&GkLfJI+vhv{-nRM6W(80o;LL#fI@l@?y|3T
z?zF#=sVI2K+#<J>C9!~Z_7!;7)9#+o$|JoL`sZ4(`H8S};cCx#T`wGue(M{XLIYgp
z(~Fl0A49*d8~Xdzu<Gv@E2y<t%?Hc#HEWc*|M2}QD$|iLGGK>OcCPr%Dl!@?1#u%F
zGPT05-YV)`$hMv9PX1osw0&DX;zbEO?*Ch(6rICB*OK*Auq<+Wf&Mp^(|kHMDS2G$
z=5&P7Kc}lPFmB%O`2f_G{S|>;=M58^AcO_#Vf|=~*1q5#<9bGZXcZKP;sDDQe2eY6
z<HL?8cY9BKAz^c9cn-sVNgqyVHp)Znz(8F-q-!o4lN+h)jUQZryjAcsL414{{*H>b
zSP;k2OlaqCHi#G)7?x*`N&NAxvVy3h32<FCeb32|3hdBS$Gs>zVmAlN*>?<+)84J+
zZpK~4Hh0`F;^`M%2?`-gpw84w)g$@>$4o99GEO7UT*2CrEB3d<1JG`oR_;gwK1$I^
znAACZ^kqQwuIYUD<lm00oD04kFTv$c1IQOMAfyE`Km8<SU^1A7e#}fI4|o&?-GzXL
z(s+aSVqotyl;9yTgDS|cHemvzf`m(AJ7j`Qb3%-%+$MG9Xv9I<hI)%AgHToD|6W@#
z(KCG$NBkIkn$0BfU*CkwuChGD_NPD&zBk6!mt*Az#JLU8B0TU>uDy#f_xCjHIr%Xs
z2^)INYE%v&*OOuSwiDPi83e1(=JnURSSNfOFEL+J;=w7@1V07b4Ya}>cwVQ+mKVc1
z71-=1KeY#~h2|&aB#!x$_*7p_6UOn}_6eZ)dw~-mK^{tmg5iBZo~^3m#yBQ`%T#M2
zu3(creIYoTRG$VgABtz{|HBuMV$Jof+x5{AyCtj1?8@}HIvts5giYLy!wBu~@E{d)
zH<^j_QBhufdz(k@R`EnAzgK@wwVConWhRwZ4B_Ox5S!<k*|T+e6efrO9u}XriZDmv
z^L&QK^K8=jcYfTxocmM0buqGw^w<>w9i**HigUJJG*ZKEuW;yPf6Pg*V6*FW8Tr{`
z=0?>RIlR3LyStld7Qk_hwcv2p4(E~XC~2C097J+t*O}e;U_8(VkGRT8-C{;d8maFu
z=ov663#S>_TojqTo9t82cP}|s)LcF~)o=4%3z~*onvF9HCr9vzD?#R=k*<c6c^Tvt
zt@z+<9!Yd+1)<Ury}Rvs)5o4YZ<ZZ8FqE|A+lhk1r@{_C#D&s8t#&&DSg~-)dh){<
zR>oZeb!Ox(fnIRBw~TT1bWV3BX&~7*dcPTH+x^g_zdfIf5s^xEb`_6G0>52jVGoUU
z0<9Z*06;zpQF;>7$!iczWK0rmk}%w~Sm1rhH-FplmA|zEWR^c_wdr$5AW>}FE9~;H
z-9nGA+R^4N;efteSV9@E2{c2hqrJUifeRCeV<Pw1$e=FBG#VUv1GMWRY)R(VoJSu{
zZ%j+}-l-5!BN0$M%6OBWg~SZobXlEyl#MQrMY|os3oOo8hjt(e2Q)Cz9GEL_l^B+6
zcYL|1TvN!6imou9E<ZI{nxJw}$3~}}Za`6jgQA8V$#?FS9kn>4F2omPyCMLBTIY!*
z0Oa#kkW>{i&Xwzc_IR2FREZ#uW$@NQnE6ehB;La^8)fBeYcr_@t%k4C6}-tR<@fPC
z=3)Dk$XvX@jLL~#<RZe`1!Z+SNTy*@pKpJ*^ZgG2YZn3-nAH(;h7Yn)T2kQQI-ofc
zwpx}qyvgfS^6jfL$YdK|v;-m_hfl@GGcy}=%#h2X_5E4gU>mbT?FH$sf>qJRFg)_0
zRIPUFNggwb6km&Nx(2GCvnL?QQ_wSXaAzN~`iN1~O~f*~&l;0_i!+6z64<X3JR+C3
zugm9eo{;1!h&AV!%oOKw0Mo8wOfqC&pBvAjFGobspb8G!^zn)cqLa0B0N8F7GELXi
zn_hl3Q-4QIU^Yr%;_17O?pvq?{E~hDI{gp7u>6pU-j3q2rjZtqJ{bO}2MV!g1bIj)
zpe*VOVG2m)puBK`^YudhUZZn66qT*6oZ}`n#fb%(9D&6RQ36UcgJQf*MqTd6VdDLL
z+8d;MRtB8mC~qRSGznWb-MpUd@u%!&Mb@#GB0y&vmaS+cCl_jpg9)6DKVJ(H`aoL+
z;sX^3weexmIaNCmVHquTgw;K}LVI&U`-+CRWN`?+oZAE-X&|K?;+e_!?SdF40|Dz=
zYpB5YX*izR^{mjQDGn89F}S(gYwt8{ZMDFJezdurqlx0H<uRGl1*L0rVbg-rn`-wb
zY{~)_L^egW_sl%*NwERanvvcTj-D+4paK~!<NLQm(_GKk(}E7+^KUIOgZ8n5gq+?i
zQSYBkc?-s?gd#3WRZ#h-IJ}l?#o(EY6zjY4>GNxWzia8DJd<|7Ma&1Z6#gOzFu*}7
z^CIbp*qMSfHo9&KnKlpep@;iL^OxhSMWLN#Q?7=dK+=4BrG5v~#@E5Z&}8TchQ@(K
zLt|a5JP1gZGSBwN5j`cpz7Nub0&9nnaW-q95=2<lX(&#h_V2|gq1s;jRWgkgu1j6;
z(3}yZ%SdlwZ8uW_Hq8$_)gR0xhqPqyJuuv&u`Vw898uMk&450d)xe7RnaYA4Y#zIo
z1MTCio`xrnG?d<iyU;liDm=}VW02XODTQxc94TNa>ciqf`<vH?++H7gZ&=?<9McYZ
zj%jPLxl3g{pG<zx^!X)X03%*^a-=qqeKKa(J#}O?GKGzd&Ci}j#&NheBc+FF9CINo
zA+yn*c_L*5nQ8-J|9Ud{jq|oUaJuq-T0O_837I1i{1*ZMt{YNOYqy8=ey!o}%L$^S
ztOB#v?*7JsCBvVdhuA(uy>`agsq%M-1x!xG7_*~hbYt#aQ-pFO=d5sm4!~5Pp9-!%
zuN%H>DWQPcZn}Mit6o6fieJ~tZb8rP;UO98EZ}ZOJp~9B#}1GhzC4WKa6@p2R9SEi
z2NBiYhhDdF*)-yy7!i<#qAYGh9%Lg-$r><WXZ>t`lm;J6c7Ra<7_Kb&FfxZBNSwZA
zpgaPV!n6AdF14Z@Uv{d~vO)+f>cp9;N#sgXoy1ziGU2n16xfD)Xcu?bP3rM_Q<R=7
zFUD0cgR4ux=ff>VVmLhkN1eW_#8;MfH!(s79<T2Xi@Uoyt_NPSeW9I9UV%|?^npCQ
znG0D}qH1pv_UrFvKq1MJX`W4Nv;5icUDgCPHW}3BASkgg&56SpA=iaA3MF$^^*vfO
ze-b9k@5q4hykZG-=(7V)-;MR`ILXaUj^V8UyqL(u?;F0GKk(Fh_N~&#7A1|L#hxSx
z!`()ys8v3TWWeZqOsHD?7tMi+BJ9{p$LN4B9a-&!^rlPS(YY(5UqkVLgQ|Wtdx?Ls
zc_bb98wR>$p5+23%7A=G-?_FK?&}N~!iJ+ddQ^W~;|kPEkLXt?C)G5fef5lhC4*Vh
z0EdT1Fv+$n(Mu^O5jnyFT?Y<Ls+lA{4NHdYRU%m;;O}jYlM)hH1#VRoWKFMT2}cWY
z;F|RUOHpBSe&NLxgXZl82c;{a^gI*di?ZGM{kojU#~LKrrOE_J*J>7xiu63l1DIs?
z7vNZDzeQI*JsC9mi0be6Nyy|vaU92Kg#Fcqe&Iun17`bNIp3E}_Jk#_-jW!&cx(uU
z-*6Bwh+xBQ`$F?OcuS-J8pYMI!M>yc>*%gY)BLDtXajk3jMvLp%PJTO>hc!hAiGy1
z18kLobu#s%0ru=#ffX4=;<%=Y^XX!KI32Om6$TRl?}h@W&W39wgQ?{BjbeTn9r<8-
z!<YIk-vZVa9^id-E?74W3wMR+lmVY^@V7(<B#^gztA@8mVE4)3uwr<!Yva%F(1|f*
zn%FqIpJS{P=pE*Vu>~vr@=Dq{MzlxiqJ;RBh@B&_u=wj8vx10eSQv`e&)<?J&JPwN
zBECiggUFpiSSSO#7oWGeyTL<&NN$IFC^<1|4;Y-flhGkw6y@262|~pDG@(}AO|>0b
zP_Kf+Uc$CY5OM8R4s7dHqrBHup^Wy&{&eZ(8iYadL}3=EV^|Q?&S&UuYReYFT=}bS
z3Bq0T{mElZlK;0JXNmJ8T;W5bXyb3^vc-ZBA$%h{e_a#w!x(I@t6)7UuSNrdl^JBa
z3WC|{5sZKwDNyMgqYLvlO~21#=TB)g2fo^M|I@AqZ#}g|5UF~{Ne&D~<0=+P0z9}n
z_^_7}4mmUS5fK5+wAq$vzp0tGUqkSst3d6d#pBO~alDi1npkh>k(|I>Wy898PBjgn
ztIj>|i*odP3u_Nlr`dk0g0#LnhrU8Fi>}<&^Y@;kZt+bE>^T4em6xVMZiwy;!=pn*
z!$#5huji1@$*}F78v-k}?8}e3P+egvh-|81*$ZTxbZZSA@L^LANw&h1O8jg4g18BB
zV($NFfDhoABT35^e=eNnZsK?^JVkoZl}udF^FFtII~x{b=?DAn%l5#bnLCf!@>Y|1
z&}fdfdiO2%<zNO|{d-K)wKzz}OnPfvuW-wb{**(XDHMXSqjk9HFJWKLP3!~2(vQ98
zeQo<9U)^cKhzC5}FQ{p(oO~2P0@r<T?Sv^xN0{eio~mQ26>9S>mz;WJJpzFOZIfXb
zhR)J9A&d@9mIYI0kU5LA$?SQ4q5!goocdhSm&@*aa3>@5K}Oix^Dr88D?2uc4n_8H
z!qYw$_$Hp1uC#4}Z(|^ml41XA2iLF#5y@IF9R&%l{QvcFSPX<8?tV=2UMJy3Yja*A
zL-4#quw8xUg_dqOM6v>rDn@LZh8<VSs5ycVS713?unE|ZKt(u6CnMN`6vmH8*ZjmL
z_;F=t3|sI!zib6Vz>J2L*$Ly*_HLs?b%KE{iv5kLdy{1OQi0AgJYrAM`z=!UF{N!>
z^7l>j&$$9Hf%-O0y@3b{p$#0tx~i9bKEH8a6gBPqFAgg8d!h~WVmp}i1d+tfkD()?
z84&bh^nbt!L>%2T84uT{?ZvhaZrO~o?bF{mef`8dAbN-RKknW#C=M;y8bt;M_u%dl
z++BlvNN_T^yE_c-?(UkPAy{yC4ess)x4@g6E8neGb*oO*_kO*<GgUKHy}NgJuhqMk
z#bJob0e~!^1l9tq%jRyE4{zEW!qye3z62;c3;r6EAe&$EK}=WMJrw%YlM+8v?*fag
ziz`hOPFEFPqgJ&J4XlRY@ky0G10&d&@6N1CJ_iKF%@-OVdS@&OFJF!jswy6J_`tjg
z_qz=~Ee3Gei@eqXm#hNcTSkz#;WGK=Gll+V=OF+X&I3yypg)I3Y;kr96^pLQ2^;<g
z4gob)Qm2GFfP@#Fn>zq5J+ep`3UN^;`;fml2Zkpej0Pponjr@PM@i^UcjW@$aRcSV
zp)i}FR`KWnT>)%EVBfb7I>_QsbLcS(lYU!q(~EJwj>iu-_Ws3txY$A+%wj>fYymO-
zF^3$!n|OYQLr?*14x7W7?<vq6F7s8l!hrD9CgMA=-Oz|+xQy)qT~LEz_zd{uVA}4$
z7zBDB5Jsqus2*e?<W>L%)p#b4Ev?1e<T?X@my`4%03QAWECS2>7xHc>SO$yO_k5R|
z+dU{mF*8CAU-Oz6QS8jLK*`4;u<%%*KF}rtVWe5yuNSec%4rNfLBgTSBs0l&KWx>t
zEF3U2nqj>x<b~`vV2mF>=@gR($KFUPtMNp&C+ERLu4oV%vlrLVOsPtd@>ehJlV9I>
z!-nE1n${MoDcIfu0&WiAR&n_5LqXn7@Eg5q3PV4Ms_lm}lLWt%Cz{qqqNK(tUxw<i
z5-!>sfG)l59pSMGKPqF`WRhVX@=A*43J3+?UtR1>*7%FQy}rJ|;^zmzVnJS<0V!q4
zVNLXQ;@E)2zwq>)d~4NU?r72rLW!If3&P02_=VwAiCTpbblY^$ID_RMBUR{o@Qb23
zXS9l9c(>DwVg;|XjO2M`#bHB*v9ya5WFV?Ti3%J`#YsE{4(kxjJMEGbO{0vxL;}4j
z(=;70L20^iqIPM9d0~VJJS&bP08?f+zBJo;M!PJ>eLI6L7eUb}hG)THM*(T$NV~is
zj54#lFzSs%U={kurtzfkA63a<K#WmlMQN7Paz&Y;0Y)GGCxo3zE~)7Iipr|`<;tp>
zo~LCXZT6IeExxHk7ei^G)kg%{DXX5ZT+_>7L{VR{cZlByma7{kC5XN@%A3UxFpk_v
zgd%VsjaXOW=LCc@58F6NDB)>L53>*GIrX^{^woxvipK|pvh_5w?>0VPt<-eB!K@Mj
z^`e7RM1U8tF*s=~b7vJBUR{CcyTsY(A`dPzU=yHfkxKvL;SMqiB11A1$?v|MF}`;z
zJ4gl4y~GV;oU^O;@KUv~SKK42N$C6*KJ%B~(ES^wgn=qWiW850bzgx%hlWXr03x=E
z$je(ZjNvfdfwPLpZ#~I6HjD+mrX};DoTgkH)u1>L_x3IcBt0#d{vT-fl^Bo#{(2Q*
z`^Kpr<o#V^G)#OCC}?W!T5?|GiF88gDcZrJIN<>Y3`rFJ{DPY0ydcun!=j5JF`;Mt
zhF-XO-*^cS(pC;5y!x&X8jiZEI2`N!p)+8Zk~#niS%WwMMRaX9Fcp}5;fxAPJd_$Z
zTm13M&)Ws#ye-VTOHMeqi~bG_Dc}yaitxcok&0*sU2X{HX}%u%#XfPN(B32cwb9-4
z^+xC0ThRdesvyi#Jx61^rx=XRCQxK?ItC~bPqa%8b3@J+<8vcPc02_y$h8;_XY<BP
zdVd)53T4rQUC0(f8w_*bGzHzwHwLT#hwlYD2Gee`g{{bov7S!HDG5O%v15b+zew?W
zZx#kK>QQ269ZF^Dcac7K^&`7U2A<$gku8e_Ip9zRGAzQ9P4Gd%jmQRW9>GB`SQxy+
zbqIudC?q?!2*y+~i_@k59pSY~MfP0Ii0D8?b_=O?dFq3u-*4$co}Y`J)<r@k@516;
zcC$Zp$Fk#_QrU+CP^#;tT{Q|IVz&VP2lhdMft^^-8!D#1v#=u!u%Ehsq61qfhV(&1
z3s8j8jlD5`wXlS<kO#jU0iiypMMUEW(j29RvDOcpFo+nT3y=wZ({f3&w`V?6goI{!
zEih;HHnDjk76`%hp@>ZL8pvHa^&#XC4(sqHOtjT7z{oEEV@>uz;CU;W*nt5!yBQ{W
zw}tLqY)p2S9*p@IFb48T%Ero}|G*?biP*k{(X1NE_Wm~<ZhjaH>!JxYr6DlXR1C%<
zJeWDzFk0ok1hTRM6dof)pU7t$&6ZD!94iBplGq4Sk3RoHl+|1j<#*9;??5akh+^%c
zOlF7_6sWQ%08lH2C_W?xvz~#4@DLDyh;I#}T90ArcIzsq&!oF@{CQR?0wxz*QSU4X
z8cFu(tJfOSm*+?VR39-|Fv)vE*pr1`N}jq%R8(!E6D@#-*w?6>xA&$@Ra$B$5;*De
zHfFp`kt`0IA*m$HmI_%KXhT%ruT`0?_X5%6_{17ZbC_+dPew4tsD8Ar+1mB0g(Jjw
zHT96NIDUGF-J!&5X}$dl8~SPWK!UfmK!L^8wJk;hvM)6;g~h$?WX(^Fw`G)B%BItL
z{krgn_SU-#p>L2m<5J#^s~py%UsbD~4?Jy`C9M9>CmUQ#_suP?_CQ(kl{ZShZX`eT
zfQ@P0D_oCmtX#Gb@3~EANsrEV>uh0yLWRgbcza1n*&`Hu$T6_BdT9;VqjYVEaH1Cb
zIda)!WMFshfAI|pth1Zi5gU@i@(&5#)kTKb>{2DA56K#EB)#!h@6t;0kG%QTCs*0*
zU4zqGL_0Xr+FtY+z4^zCSk8oq^~}~qJYeBTIkQ%TmN<Kt#$Z#W0IN0!g7@6SUhABB
zdzi8I4-_zjU7Q8TF&cd20@IPoE?5E%AW2DqncCAXct+bJc^Rl#G>5KCnzJL7=Y(3^
zLkJtsW`%4K09b+JuF^d_*6bDdRiDfK)!Oz%cSm5Mb)CD$`|RWktl(k~DNkLL?Wr-9
z;L?ZzPeaz(skx-!@=Pwz_bS^nYh%Hc<#nDPZD(ipL4vE>q!1(9o;w!_t{ofjwym6<
zyY~vNU*+=tJh8p--Vxk*TIcP2KD+RT721R$<LgGYd%Fyx652xg!q-c5ei<eyw2hU=
z*Ux14JIYvShj4>$Q1JYBT#(Q%B^m#)g56b8k<cFF7yeP*^Q*L8p?!`#{&8!&>#QB2
z1Az_xN$>OPJXqmF2{M7{D7%{?D&ZsfF9Ne!=Qm}N!pG`)0`paNw^hc%CpsGf3vK7O
zH9^9sMr49Zqjq-<MZ#xRUj$cH&hLKo3ZFaW39g;k-M8%sUwCZ@ZakmgcfyKXLIjMq
zknJCOsYHH9ei7Osx_B6r6uC;w6WU|4e;hRyxz5}WIuN{goD34VDI^m<Qm}uTEfTq{
z{33j!d-1f;D{@z#CwyjY|Gcsza^JckeBpiZyzvGr`p`or@;l1@Wrs@iapa50b=Jkp
zfu!iuOrFSXmHnR+W6|g34Uzk{i$51ZqA%NIqK~8Yuh&JQe~!P1KCfK7-uH^WUge4Y
zIkA6x-VuF!+7NwvzIc0s1wkQgLSccR2{)lBK`@LEaUT$@07Pj91d!hZsDt2iHsOpw
z@K&4fP9UJyCJ+olh}=X-1R-W_B0~1cRBj^GgOFP{k$XT8DR7h-5bE+K>NW`NcoXdk
z1kqeZhcU!J+QPsx#3bCpq%_20+`{58#1`1XmN3MT-@;Khe5bSZ&d3ngY75uN5YKB1
z4{V4ZxrLu-NRYWjP-sY4xkXrSNYuKOOVndXJhDYRV@R^RMY3&3db~w?Wk~k4MFwL;
zj<ijVWkf-^O+jfy$+%6)VMHacO(kJOEx%2zZbYNAO=Dz4Yqd@5WJKq+O$RojkKCqD
zG-AlyW+*gbtlVa-H)3ktX6i9|KeGLP#)x@&n|a%a<#?Or%82!8n-#{G4QYoB%b1;T
zhn>=xgK>w0!<bWGhf~6sOMZt--I!a%NDK;!;_vb`s5hwhZ-8rPXeekXD98xZ8|0(^
zi!Yd<xS+}bwUD2BgL*?GmaWYf2NN=;C)|H4=ncKz4@?RR4hlsFa$2np)fElKkxNDr
z%heYTC((bb)EllZ8BJp|9?6z#C>_t@b3R@jZYZ0~6AOx*6Dx>ncS9$U2H;H~gh8-H
z`5gK0mGf0v4OVL-->VjCK)sP93U_&-$PQiKv(j$X)IAk*rEd?rC6^LhPp-zS@4tQN
z@Rd8>8{suE4D$R#iAK!hINTjcrI4%GQg2!*h4;<&88;#r-I*8000qB(2OOaw`HL^p
z)H0`r75g)DJ@@gvh_U<JpSb&tSy*)4@2H6$4y*M^OkXD2`Ip8}R$5aQ8(}qCd*Z6r
zl^xpbXS&q<-pcsbA5|{C$D|FmbO_onN5<TzqBr_V-`<R$Y)p1``X^7x@vccZ>JMUi
zU3&t*fRW4&4E(_2_({HR34{8M5HgwA2FogqBt&1I9wVGT;n2{U_H+4m<ol*_d^Kr^
z5UA7@{cmlH&F+OwuwZQ3b~qZNhiVuw62Zg+bscv-D0-_T%|W6^V=+wn9JeG?i7{hO
zMsuKv8mwiPv7E>#ELWOB*>nI3HUUTMhlsY)A7s1yI-1qCv`w8;pC|D6k|+${x)U#D
zg=m^6GZ0}>7<TKiomP>-RgzDXD`lBd=!$3<x(F?hX&Y|TYLQ{rF}zdi$Pu}nQaY1b
znNvIP#&}XqWqH{p0n_m=4M?W9Twc?)Jz$woCOvFbh5+AoT-!@YRIM=bO|HCjrm~gB
zIu_09tfqrs{<y9>#B<qe94jif>8qDE{nyi`lW%R%_221Yc)+FAmD>h{v`OYh-gf0h
zX2+I|W~n;gx~3%*F29H3u3U7_qGiADS}SBS=z1lT`&Ni${8UzV(!q2!L|uijqc-!~
zQVQ5E(stJKEHZLAh-lqbtIrD@u`fZOJFSi-N#Z*mpg5?inU4K*^tEM`dF|S}9QO}L
ziJtn3{jiq#S8ivIN}3DFR;Q`@QU1>T%Xxw%W|Jiw^zq-FxMirk*(DrG#MARLJ{NO4
zpWjgI`T&|=9p^kpQQwDR<8|C_NArrLer+yQyohmzUE`T(6|cT;NW)uwEOYPlEuT1Q
z&3v3t21oENqmsq4&WW%8X~@??%6;e+)iG#`2<kX~xab1bd~E0B_<pshRO8DsGaQte
z=hJb%&VOyX@JgShAz<5l<XI-qeja&n_;gY*NZRqxc#Y<?rLMbC`&^>p)p2>VVDGO;
zH_FEvXmsz@wscaId7HV%Tj?9?4J7_}rv+@DpJMULKQVYN4Xqg;NAaDe+JFg}7a2QZ
z`XJ7!=T!{X^*F2;h|->iq&d_R4?!|OS=m3&`>V4*)w%|5>A~#%kVJ=(aYi*6gMB+Q
z<G(C%Fh5QNO}nHwBD`XV()LlHKT|fYW1ffqD$IXM#_PxR`W?j_tmhJ`NwP~aA;UXL
z39n+&k3woL0$FIXDS*({tc@6Zv9gK)n@)?d%%;1sLlAm7#4A4F7-`OF0x25%uwGH4
z<D;qng#Qq2zNs<0siSy_=fkHZ{hFY>N`dw9N4Jc~ek5MsX8l9?(79?&j9#=UlS)M0
z2Z1YpEgw^6+X&e>xvR9UIh|K(-UP3$@T3BqBo=JXul$4#J}QzR7+skWI;#sK`7xT-
zb~q`MTy~2Y#gbyT3VFLa^=x&i0@l%riB`DloXcQ5op$Mgl*foP{_4-0cFk|n_B=H?
zetji$1$^R%`m^eqeWaZB7321qoY`B+i2T1jWhY(PV|^rv*G};#W4#)cjiQGZ$R&zk
zNIpg?F6UZu0O|<s<_a}j=;+m2xk?_tDG`65e|8!ka2eoouRS%{Fz{;2NLMd;eL4D&
zu=FwJmtziDOr^#jNgO^lYRVL@(gv>?C8LtyvQ73hWoEv5#DQv&1|b#ATj|jft0Ut@
zz=_6zyyk1Tqkv6!<%qOH!dIvHuV+^|kz<UDuQ;D2ZI!H5$8;731bFyAr3?yDD=ZC5
zOOak#zyQUJ+XiWIt?h(Q{iK){l<eSYbCteY4PQa#bpr8+#H87c6jm1BV1n?KwZGcw
zhA*!@-Tmm|9s+W)L002$HV<*LIPp$Fp8)P#Vn4ojDN|Tm^UH_D?fT}{FuJyn^o^!u
ze!{<pDfx=6sr68)#%n<rV**VRmXKT=xV-{B@pP+uXu?!5V$}B%`?2-t*qnP$=i7Sy
zeHVf<n?H2*2(*7norMXT&aLPA=fH&wxR6S?kPt06?}uLUR20waz0GF%#m0B*qu1&$
zjmQley{9*<5i0oGgewmN4HTz3HReVHMJ#a!47K9F1&vC1<|_o72%{Xwc4-B*3jnXN
zs#(eWWJQZ%;!;P-#Z0DIkqincl~)OO&(g|;_Hl3E&G5e4U7ohbxAAW+G?^9Etr19z
z7JSw8VKc2$(~sKW@j5i8%79%mBC`>WJvz9pu|sJ=FK-fQCv{}cL&gUA{K60Q6nQ#Q
zp&ar)$!-P=MB#XO+sVOfevOrywmU&hT9ac{E?6l-b448{X{o6+<O^IU{`<~z`M-`Z
zCJAjm6Fo0}oj9sOKI+xr{a(td+$aT`deUTDzdQx+R#2dLl&;+{G=%n}nW)Wrg`cfl
z0M{i4u@$n0xW4d6@N?e6pEFcMw{;k<v*!D8`^}!4kNfakl;$X=C6rIA?RM@)f<I@%
zj-!|NU=Q=){Elag7EPbde+=-RFZ!&Yx}u=k)?~$8iiP3T^1MYobdwqIDpSP_MnXih
z`I{%BonQ9(F3Jbfn132bYp?a4*AE3o+C|o6XBm**7U~(;Xs0>Z^GvqPm7z&%j-u`k
zk6rc!*-aI&I@+?;<e#keRm8&zpIYSQOj~ytSGN5*i=xUYHC%SK%o5nG^IOV(*ES9_
zpu2Wk>M2-ZzH2-FCrH+vXBBVqp?;YlZ+NV2SzFFSXmafcQHFbLF5OK<Fy_?ymY`v8
z{b436*CfIHM~&S2JW3|XrIv=z0HT(QnkdO!jeqNA9Kv{U;_FQpx=3|3+Q^W%*VUWx
zUBbMGL~g^!tLbliYn)d5Y7_0j{bWs-KPG)~zyCQ#d2)FxR?@Qj?WSu+^LbJEIo(Cz
zV{-&eoWs6njm?m5$MeHvry(cvC!~V2LIpP?Z9~wLW&pev0YFO=iT5*b5wbcx03tkz
z#TSU96^QE*h@T!v2vH!#H+uQukXJ&6h;I(V_l`;nn@$!?!)Mr#2xh(t>?sAY@zHJ4
z(r|`*qPPXY9)jO!JS;U0ge-!X%KebF%y55c^RgRBK5$N#1Ud5%D0mRKnbR%dgcQ5^
zewH?Y(h3&D4_>A9Q@htRI5gsZ0BwZ5S4<DZl`!~x=%d3KVyzWwMH5Cz>&>baqK)qm
zrfJ1D8|1<j`e`c|DZ~$q0Ops5@C4ux^$!8`&a!X#VYbbb4t%zH<woK7WNwGPOgy2`
za38h~<b9hR;;$lv20mT_&1l0+LldbG>wWCGnTx|cgDt#=FvSCkyvB<)s+#d564^uW
zK0keT-%pCV4wJXOk9vX8#9sIS<r3BIK`Y@FL5~w{>_*fjOZYQ9=u7Cwx^(q6ya-($
z8ToC}ud*>=pJNvnV~!u37~rD%!(%?la#jQd>FiUqTf}JpitNYtFzbn3e)!zDXw$Pu
z#N{SCKNyQa=VBXXD^=qCa`**t*a2NT3X4A)cS&{J!q>|@Uem&3F3itx&*94fBcWV;
zVSNPhkQazYOcfm4*JQEaZZ_m$8DfDwDj9YECS#%JmUvp`lr5bgyp$;Pn1sPEDy41h
zcSr7(oW!Qd89J13i)Wmg=7Evojf&^%h96%QmYhCdt^icl^mHu4PZp8$|FRTMSrM<7
zkvfX+kDun-$>VeyO5Ic%<MOBiSTcma_E?d&f51&k8zTKy=Ic6~P%vPYB9qj*@9Z9t
z%0O+a#gKNK99?80gYuYamF}+Q>3(36GQSg-SQh$zAtm}Kr4d)ySCju8f9lsXr{ao4
zKVW*|aH?TM29a4x!IIyLObX`r6l(@<nMeDEmekHbkH>+ugC8nww5gND=^c;haX8sM
z{2mMN-p>g3o$kSFO&J})R40Jz>QeIP+hcYfAPxRNH7djPxFvUrK=zY%uK8YWu4nF{
zT<)*^gah-?oC@oei0o}d&f25YmbyHwgPfxlmUivDO$Pa*!L$YH94lw<0#C{NjEo&Q
z7p|L}JpKavnVh;(IgGx{yz2tX-MlEbf@W=tD}FclN}rDz(htK05f8bul0GCA1?OpD
zPe+^pFMciAEPwMn%HyI@u82I%RJIY9l>0pL${bhT9FeBX>xiNy9u~&Mq7ORhgM(Cy
z!+Bye`OKMqEMBQX*crNEcG>RHixn0hD~r#KL+B&3idq<tc=NO?i?Cq|>j=t*Jl)hI
zZAqU>-A5dZ&5BBK-TZOn2`hvH-sFqOx1DP4LoRvBBc9}V`N||JeZ9Dx*!Ro(wDN&g
zrryUH!A;5dCE}HGPMc*4FS`|A3FD<dd7l#G|C}>k*vYIU2qzM#oLlnN9IOaL68-cP
zgI8%Es-tWpP$gkyp^{njeW@DlIBCi%()p-jmP;f}r=n3OeVou4$;x2lsZ3=tr$W0_
zU#9$nxpSIad4sH{;<7wHeN{=z*Eh4O^5b+^ck8*zvV+!==sBY<fr@aQZ+(%aSG*Cl
zN8f%#X4)0GIJeX`wN$Q+d>yOIfO`6h8WldzS%Yv=gBMXjI$Iipm^~l)^#T}!Dpy#s
zkTCpM+sv4seGu(7TsJ9QYV(Fr#hR5Phy=PqYLMp1jy$NN(sh%qv@J06vC1$xkMK@K
z^1{>3G53;Ags;nIG_I42bw`Q>27ixT{HwuPteLFvYz%)QbpK@Z?Iux~vARa1QYo$J
zC!+FkrXAX-th{_Rr$UbP=LQX!#0c5%5At>F{9zUJi7gCK(9e~OgaYrLNzD}sBBOjJ
zA|v;-v!qwPn$gz(Cj7xA_&rI!gpDw?@K7%Ksi=B5BNtBse>9rrMA{EAxn-o#qq*hR
zQe)srsu5A8q<kL6-uD}%#*9T-?9cU}<uZP6_c3{a_T!QQBBfg0W_-HTi-z{C*4W>i
zbz7dMtqLW~qd}R1F{*FCGz(tUc0rHg%%8)po~)Ig3|WQFSt%7(ZLPYA6kaYmN8VOU
z(TyXCmn{vOd<}jIwO{3|)%iPk6k5csT5=SmO1;WqP8$NEx>lmfLepAbGaB=~xnSN0
ze?qR$^vcp(s*o6MAwkLXdhl^<aAvdYHaTinv&x%VXt;TH)bZ>Tng5=KCo!7|?p6rq
zA?{sm?VdF60z|iZS?4#na8KiR+8+IY$!dWGI=p7ZfJ1xR!mA_r)AzEJYszaVE9)5_
z6Z(JHmbKQ0KSuN(MJo3zJTkb^Ys-L|)3V$`O<LMIEps?+7#&X=pPOAf+7jmZ{J^6=
zy-WqPigg4;W|D6V-I!(SxG6C}hGx8C+L~vIHH2?v7L~tD5{X}|<t_c<U-X3~WhLGX
zIrKGq++_Wbb*{5=Da#xY{SZriqK>lDnBQKG5Qg6)K!egOyY3P~R1~-4G5R<v!29WI
zP4-yXYTvc&7)4aQpL2=zfnT0Yk0#^0w8v5RQZxPbkz~P<>S*SK{lux!NQY&LC>tje
zpHWl%$e{0FdA{Mdsv7DC5FWO<*&!>KVZxSXWSasvIy>#IeZo_okv2VqmN5j6Zt6uS
zeld9xU3ki2uU~GJVSX-f4KICEEoo;=H^_#dRj%6(UxjeZ2j6#Q=TpRymMcOQaa1&z
zCT501csBiwDxDHl$Gm*%)H>-}XjbHGR+!{d%p!gT&YU!YPnheh=+8ODwK=15SC`Qa
z`Lj6<{duCrnL`B!cB^^4wRz>3`K6O=#<O`7{a-zF-lIo7vo>>PYrpK2TrK|8ETatB
z>o2&G1mZ8}E9%C%uPylH_{#~~G^Wk^>o10`*@t{@WnpLyTU(4Bx4*ypDWp*sr@xdc
zY&UospCb4xZEY!6Uw_@XcB*eWPk*`et4_hsZ*HSYWoygdlr#%D8@CjeYxGx|P!%12
zRy*BK|5#h;So5!-^|ECe=+s{w_!`iCR%M$tKe)C!aW)-S*+V+AI;p?*i$n+(<yQ*v
z?84gG`Wy4y>Yuf3;q_hp^?l#<!<_ZwpX;Y<>*s&gFG)5Ix##O8Hc;u6@0d4!Glyra
zfo*bhwv-}ffRj(C8}C2J_S}WN2@_ul%^@^zO3~NhC~f$hy5br*!r3higEu)x8mhlm
z$-itRQ*4`*4`r7-yz8jRNZ-cD-NIjV!uz((+@V!|!_xQ@E1ft!*j8aks}o9bfyHi-
zuy?VeI$5Pn!(Qm;r0y=;QD3qWuAIoimyrqk9T%bVrc$B3ex8^Ii;*Ln?@+zthQzxu
zUps<VcMnIm?{s^ml`G+vcBE`etqrWV!-f!a8m-YnNya;;%MKc&6Ug)in3eWTnOEsh
z`bgeZibiw?=iBBHQMb3f+MRr}gxu@o<dgtyqw0TpR3p3L6b@r;4+}lJq8~D&Ci+O;
zXEiHqi`aba7dXP{ub(YC64U8Ov+lorPEtfW4k78t&B~`}D6AUg0WuWD%XTD=SBx<C
zG%FUjDtpMZ9yN`W)sCD<7_^x=A9kHj3~9Fa<aT)rSklZ$<|%lNPMqRY%0&`(2_tul
zmRqjBw*K-vi>Y5-&TR-lYaeIuswz5`8J~69EmYO*$q7$AYrTjYJC{8@Z)TC$)#<xF
zUzmHQzBi}}dOaIJJimA?4a~U+Y`Cni*fp?fJ<!fT@y^s5th17zDlzW6BK?gOchLP7
z+t5<hnZqI<P&xcAbvZS+LQ3({J@*?>RO)^1RmJP>y5xz?;4xd=LWjsPF6(fqa)rh6
zcg2I>f-RRm$iIKDE0wXVXlEs9T9=99uh<g&RNS~hAL4Hgci&n%U(o5T{8s(;Fo*n9
z7U);bu5kPPWcPjbzIBZ9*+gaBw>z#sH!TJ=_BDr&{&!8e_iZBQ*ghso@<%7D#R<cW
zjBimo0xLeEJE1lHg!b1JX|9RS4>A6O<^I+79p)d=hsIAX=S=+3PcJC_Z@wXfVYU?%
zsQfyx%bj)iSz0I|w;w3AJ8>n8UHR(WN7e{-VbdXNC>;OowAxyBA#SzS`O|)0_wA??
zrXtOs$CJ`0)0qFV(tmKc=4DRsS$`umdF=33da8<gPj~H7A@k%{`yYGX9Xb4MsIBf^
zQ7{}TsT92fxkM-`iAeB+%2rSKJ7$AEEr;#i2pmp%ob=kFp15~1($vF_R0Byg=%p?M
zA8F;&Ic?YbGCm$C=L-A20tht@RSQ4FkbcP2I8rZF$`P?$oG~9P(<m_L&-`@q`J4Vv
zKRBY#r&{%<<GIX?@6L3ZY}YzMh&0djT3yf9`%gaE8g%&nd4(g^x&-xvpps2!WB)c9
zh#?UTC4M|N7*1jSGLWr(Z8njE9(Qx7ePc0GqLe3{v&?lEU#Z_2N}_vbv;6&Sw!SGx
z_ug*(r|+BHm;jf<c7F_+Os<}%VimkNXR)FK%}q#T+Lysx{b#pxo4ih&bD{Q|3&Ife
zi(G?0UUz3}4MMDb0-jqpjw_vS25)|^fBxKy)NsEDA=S1%z(=2p!r__JiUTp3R7KK}
zP#7fQ(R|n>QF(W3d+T8U_5w(#)fYW4LQ?D>-f5aRmR*J>SxI4EDAax+vhQObd^d<K
z*N4emttLYeMqNL2>w)6fgTO#MB}<nV%rUa9qyBz?CQwRUp83aay~6l=sY@9GbE!!M
z&PgfG@s2L)Bx-ha6m=#3gW?9|pKQtH<2)NS%*ujq04`N={~qT_wvRndzdOY7OdHi?
zwxYhZW8L3Ox5}{gbIpps8xQ}8%?-z`p$1FhtnpFhgX<jGN7L`0H0AVfKWUqnaF6g>
z_j7CNYqz^<e({I<EY2Q8)1+nGa&oI>nr7<u!!Rp^N5@i4!A-}yrXRQ7s$s85*M4F3
zPS<ge=Dylt^aHQHYmI=rzWYW9Ub)*&$qxf>LEk$A-}}9^R;_0^zD=)#cg>)nHkt=e
z2%a5}VJKPXgJu|2Y4f%wT@#;ijAXxuah#|@qj9_pt+sN4f;7J=v&!cd)3lJ6d(#Z_
zP>wH|_5%bmS<d?{=4je?{1yeXOs*D1alcr}|8IDM{|_mM|KI<V6og~Jfg*-*EYeWI
z2!A=2?jQuXSA`)5irz2`WPxZ|2g?2^AhW?-cwG@N7E|1-nEuLeIDu9sS1QASMk4LK
z@yH9p$L-E6BKvKW3eJCXa57LlP^eJYkpE1AdJBoa%-;+`dBdV@pQ1{y4;zW4SCoa8
z@9=#(U-C9KGJ?mCrL~<2V^toEcvH_NPelKcg--uwx+zw)H=6#&cUX(aS*o1N=iho7
zp?;{8Cm05=<ke^~!!1RJ6oT`qV8Z($o0-o6s^Akut$C?|`&a{|22r${U~n=|mlj`D
z1j^)n28X#IU!S5wSHK4H8)UQMe=}C9|7{xx|MUmB4n)xGdA-h{m#(^Ag+K_vigsh$
zk_bU{B?;$a>*26LVCL|lQ`rFqzTv8(cw!pM0SHBW5Vq<HhoaD^G~ypwd*p+eIqi0}
zr_4s(ubs|?jvBVr3fNU}O$js@CQHSF66f%_AsrlEl8D~&^}*~{$r8VD!e5LZ8*~&(
zZ><`S7pok43-=Zc8FfSD<uVcjZ)pd9!sL)^S!)%j2MQpOxsH7zhwr4sru125XH_qj
zV?ypj;VRb3q4y14$!`4KK2;6}S$KnzakkQ&Cg;@kn=AqqQ#yK4jF|5?0+F=K;h!2w
zAo3)$Sl(+pEMhW@so#`XPpd2Hs9ZMe3m(S*vCID&6n_my`HwUGHQ2S-U&4+|#0H<*
ze!VRWgG|7N2OQiL2;`)VCa*B;3%}my?w#H;l8!+l5O|??T<1*0W6za(2rQCGy^v6+
zo;IW%3E|Z~4wh5h9}6ZD_=Y2(LZF7u!Js-6A1Dq65{p>Ww%iyGrO`xTDT<jQ1tWu%
zzi&ZNn5x!LGTj9q2ZHgec4O6|@Z#3k8{{^?IFBym0RGdvy@oQDFQUHLC{n6R?~G*2
z43Fe3lI*?+DeK+nU6+jkHM9Bkaqnui^*c>OFmU+xF9-<%@@gl^Om5Bs{t0X*d{a?h
zcm?5{c8D`QK_`BmxE_2C3SW3d;Q@$Et1jO!{CtYZ*1JmVvq@n`GQj<Z?J*~pv%_Bo
zfBxK?NPOd{-A6GH^1L3NPg|CyiE)xgArJy?c>FRf(>Gl;bi>5PC&rBv^$TB!5<Lc`
zk?NfwHo^jN#I~Y1^@KLXVZ!Kxknzfx@$gh&^u;jXfH>scKvJLh0B9f|l!mN6e_yto
z2t~0tNXjc^meYyiDCx5vH-WlU@D`nFqA=r}nj~lfyHseVi@HRGgpF;GW2o_HKWk{U
za4%KQ3!_JrXt%;V7t?0S9N;`NyeEq5qIy^mO1m8Rft?`5M1oL?kU=GJ0O#NMf&s)A
zDE`wI{^Mc^qnOzr_a3Y@l=SqaeBqQ;0|AMDtuwnUI*>|5z;VjP#|Lg>m?QDKz3@4b
z16X?W;968`VSADpx$CLZ^QSxPeDLRlB0iQ3hBL!a2Fy)nlNA7Lb(lte(+>qAP;&b+
zUV;Hgcx856BUfKWt91!X^5eIW(~x-wKQljzReUZ(A&ovNJtu^XCUicQT0T0}7eSay
z-@!vi)k}6F(cxYR0s|ZOukzU!Tol15j&LeGS({gDptU<oqM*%Q@u5O(r?!s*Or74R
zPyM|nUEeh-6GvaGNFwq?{GQJlf<Ty5mnpJuzbX8P2*3H=TilAIvvIgY?38A$pAXup
zg<H0kg`s9UH+qbDV&xnDh|5ApllsY-P29oru?)Gm7E$zpxL3^LECp@|CQWHuMF>ny
z4vjqW&^t-b*Odx#d1D(CBb>PD2?3DmZ3c0S0Cuwdg5+-E0N;F}#G!#*^cZmP_zqCu
zL<VXV3e4uu3F4ieKjJ@0plMG<%J3W+QxI9?7mG_O(!|MV85~W=5&6W=C6lC2A#<3d
zMkunIN>jlD%zP_M5D;w0%>hJH3<o)A@fZ?WAJOIl;c#CN%kzWWYR$9k)NfP}$Sm@q
z5lLPMEQ<*n3I2^Q*g|}P9E#*Wh<s0c+1gDpR0NmdtiMFQ`}Mw|B<>c3na3Bl(8`bB
z>J7!DlSVLPFA_(^6z~J^qZ9Wh(jpgXJhB%`MN+d22;pyO_N8Fh$Ii7l@AstebTe1U
za?#4?ky;~-XBg6{WTGcgI%5>}!d4M_ze+JCo6JT_7YQ`-J4%K%SoBxwuQ(m)Hq(71
zO<}xYUaVCeZt7dwve(I{aO`={s97tU7<xNlT9M3PkP-7J@_IjiY}mm<wJYS>?QB*-
z>HJy*B4k>tf5QmywMw$t>yH*xR<`kMT3r^U3jHihBwiOXbU>3vXU}k+PDUB76I$JR
zd(vgX+>Cq|6oyIEBg3`G=Jyhci7B=5Q*o*=1Pyn)*Ppdh5;%W~==YGn)#3Y$8}E?!
z0f1|<83^wu)&oAl#Q!%I_WCE<{=>q5qb)u^`2AJa_+JZ4hAy@`OkLLG_Xh&8SzI0*
z4Eit$MfBR!)hHxmFL3>e`DToUW9UD*L2K8QhzHZEmEQ0rl_*8?89F7)HGtrea0EQ!
zYstGq(&)mj-b0p@Av3D-k#9O#C87g9aY>&w*O!U`l3K-2;FR=#ddzJLVOAxTPd1cY
zu2ubD%@go_lprV|az55aN047yalgRN<Z?%;3zX2Z(gsJI-8%EYLI(k`WC0{AQ{S}v
zB5&&$$<@h&r(IF=lzmv&X#u=UNoV|RbHZ-%4zTn3Iy`0@T_MQ9gwI!E%frqG?@wRe
zUv18WoR>0Q22}ap(K94|LCO-a2O~ZZW2c6SyUhqzc|XK&LKa?qO-p0#VAI0`l4YA=
zJCiU2Vx_`R`Ie=Tx#{!3S3{g}!8j~ZhIk~@i&#KaHdqu6a<G<S_z*^tROmZIJ}e-n
z&E_^dbH||(fKLk}Ka%;6u{aR-X2>{B#7(S6RBGE|S`^w!Oadsx!B8B}i_1Wh0H<WR
zmm&rKZ)RXZ|H+*H86p3fISIL<!+9=pdc!XE$F1ou)Pw!W0Hmvj6kFk@*hCV^2;a8*
zqha|8=cb^6lHuqy>eVjlMI&Is_ddx8oZIb*xa`aAOLcprxg2}bIGKqS6Csp_iCn`j
zRG~mbQu0%%?`4x2+;21wVwW&rswBNV{;mL1&0^6Cv+UBaKp-MTeoU0P%G!59l{opF
zaxR++0G5~D=z{&Kk>7s4!#g1kyD4;6++jnuA`MaR>}HJuY<n^;9D87p>5~LF+3{&$
zS{AyfpWWxdulO4Zmkm6E@zq|H%-09*#XrF|`NT<=>dB<!`CDN%xvnR_7yBFP+B`2R
zF@`Q*8q&tl3$71P3(U^hj+|pKdUo6BqPxI=2Xx4K3P=vEB~{(*<9c?H?1M%icL>0-
zr0-kT4EdB2h!}jDq{5jc<}}PWmHjJEWkVbfgwox&GwJd4u!GLc?sG^Q08qQ^q8(A}
z9p|3FhebeOdDZ+RPC%b7N%+wOBnBh!6DP&LD#8N;4n@pCTuqg`aaSV^)%Bw?UjQ|x
z$`=73l^U5M?WB--X#{QNl?}(fl4)!_5{Jt#OFE7|l==WMAFRD@AmL_hcYd&RZD2vD
z9Yn^+=kBNs{!MEt5H49+#}b&%vuys6*c3pIND>gqfEZs`d{j|h_ymnu@rwO#B0cGU
zddlCsG`|~=(ezKG_lBNzu|Hg@<ab8_@MMvGTow$vqi|{T$vTPmgrJCaz@`Nhen^Dp
zb~-IrH|kGg<21|6xGEY?;71;js&JwS%A#gv(~1x15la$^dhO%C><J_a&~ODOiuI^w
zio|^$Q;nC1GF)3+swz9zN`)1S_=ST!Ckc-@a`_nLZmZYn6^xV(IB`4{B{adFt6yMU
zBxE)q-^w%w6|L6tUO$q1ixG8N>tKjk92?67HwTj`@5$`KXgj^qnvz?m^@P+2BhUU>
zpn`>CKYpo`bC@pfnL|S@yL5n#<oEX>$N3T6zNG=%h#h|t#uWN-ABCQLFIwP!UlbD-
zU2k^q91S8Is}rvc4)C&@Z!?Y$$*0Thv@DV07-pM-GU@`|)BMmyHStyLVmN)6ofLk2
zC{iYcTcn$}qr(aAq8?N%f;fbW1OTR-#v(@xsJaIY1J@NWfP+HZB@U_L=RPX9>Ptbx
zV#L1#JEn0bCrVMaAYj{(=noVn()80z3Vr<C5-)Ti7H<OC)}}hdHWbW2%h4bHr~oJH
z$Ug<7l49$Dcd)|{&&C{Ef@IEO0*wzOS|IT}zo#X-T<Ub7sW^<<oOoUoPo+4Jtl8wS
z7*@&aBSMIomF2&htjqtOE`fLhDZ9JD#8!=vLA8J8<V;s~@`Jkkft*;1&6iuf;lJp0
zh|7PI1Bpn4C9;1g?LyM48i&Rs%XVKRt05)i&fjm3=aW0Wao{K!31?<<LI|t_!6PE$
z3gy?%mdj+Z;JrL=Zb`zxTL`pRx%7#_7YbQ|T^KF{!vFyT8CB+SYka26d^kCt$uuke
z$U@`~yO3o#*7r|a&TizvC{<)M^(nnwu(15?%RUwL`=2|#?5XK@y>IDOh|D=_hcNQH
z!f;$}mZEMq*^h?gWO#l$fa5vL=e}8vnzJr~8-4AMX%W)&J9}=Aw;Ie(`AovBgN#fz
zLoz$<(r6!Vk6bPcTz5;HJEdwPz6fi=VBpXfPPX5!EYesH1_XTU^vFS(!e@C=b^oHW
zbkqdVo1JTz<W3U9LJ_IYabJ@^Mr;fK$e=W+h`#JzF9|<WJLl^>9fbyJsscD;c;*mh
zhnWWzDVIY;pt)z@0KQPrF#P#jlF$gm4q`AA(LCsp1ZEI7(IDu<lvGG9)l-&q+?`Ft
zw5^~@6`-M35xgGyxSwG*aXtP;(smAp!(o7dF1s&$3+ki95sm~T!Au>%2Rsp20H_Xs
zX=IUFh=Jiq*pADKNa7u)6~cOMAXke?CIcdgOMZDl(thxCc|oexu_$EP^1nOQ|Ftu#
zg}4a$|ER{}LBU#A>wl~9f*#L)N{a{8+U>5Ot9@pdA&1=daBM_*53wt8_@KJ|@3TX{
z4W+OM;r+Tws!KVUDOn~)niGl!!%66oaMV=tI=r87bNG&+sYX)?#gT3=DO5{j?;bwr
zFka@5l%e@c2gs>PA))<lbh2&5w$Td5D)WN8=@HkFVMrG^Be>gHOot;|9be(zlkXte
z3Plmpve)e+`O{O}l}={x6Jd=fnh;N7Z#1M+0v9={+q?%-Yq=0CaEW)Ps$J+S=>(kw
z*5VEGRA=1wt-!!tFwykZS(PW+0?o?emXTqBd}E=N53mmCSjl^%cs6sDR0w`FIl<Lz
zo?tLRv)=4Mjc^`J#yj=2ry3(LZ%-maTSNfw*{&06au+l_zG?tq*0vN=Ph49=4Twlf
zn+ku+ucZpuW`3BGRI{DR4}qUfoDL^Vp^p<9lDeb_Cl&J;<{0Xu--#ZzD5OMuk0#Xv
zF9ZqtIMFM<9(YL2&?EY;elZYEfoHfFPQ`5s8c~)Oaa$DIGQT91TG3KGP2=AsfS-_~
z{IAC9?LUiYjLji$-oH&YIuW?{7gb*;It;3nRI|CEWH{zQU{YF8FEARwDx~!o03(iy
zj>F-CpibFDMyuu}3!=~9Fr8xa9NL678_Xa#SFZM8-w8B+x!amuunAL0=Mepc6TvJO
zmPA02oY9DoDQYhKO@y!VU16UC&->$>OA0ucFXpqj`X>pcx(S=$p>aO8UT6c)8jhi3
zUg~BCK_@Iyk9^JTpClwrpX42DyGPPu?v$)%nHDEgry0!@Gf(2sl+?oZt6J)$JOw)@
zO0sooEQ)pMwuSUD8jlO3WPqLg61{fl1Fq%cD68ypYe@yVxwLRFW_$i23cat<Rb+xP
zFlf{cU0#oI`}q1;QWy-RqE<P|h!SGH*Js47N8MuLII97p!mre_<4`u-14|D0a;j56
zL}JGgm5Bf&G5@9(_>B+nzGBcYkRykJ!D_@?ccrszOtARg!kZff*ZnXZgB57p7tKZ5
zCnj?>hP@jvfrOZ$C#?J+hBt;2G?t_)(Spp*<8V2dB8TQOg8(TL_tHRa{4h3}W-?UL
zxGwSgnYhIjw1}pu88rHIzWLobgf5UWkuW|$E#qIs?(jbc{y(}WP&Wp8VPF>T-`WtR
zHzG1$9Fp;2C1q8IE-CsvuV_E_g{x5whLUb@qsUED4hK;w7Y0ADP=ga#QSI~=r+4HN
zSe(5OFp~}x!$j@j-?i51tK@M9BGJg+n8>H7r6|)hUo$AB@|9Tu2CuDVY9%DuYBR6Q
zN54vv)P`7L+bSnXuSom0eYev7>6*5Gdi;(_tDAc8wS-Cjs1x02f#nqmM-`^diH>Sq
z=XV}-U2q&BygX9iVqu8P2G^yBwFP8nOAiTSV6|o_6X)->Oak}b*t!zCv(12Nq4=RV
zCjXLmEJ0dBg$jAGHrf=xH;m3z48tJz^UcmUM#x%~=YBMj_gb<wxxQXEOAWn$E(3)k
z(C(*q7A`3|-rk_#)AfD-JpL=RYVn^t@&EKps+*AT;TZmFSIIDxjqeIPg}t3%d|{ud
zcn8D2FjN|mmCFlCX(Ti@{N3_+L)mb&m6#V$A_(T=2<=*PZC%l5*oB00wN@es9&O=H
zeCI0vKs1guXn@$V4it*E{G?{=HFY49j+JDKpyskUUp?2zWs3N&d@6z33Q4Hy)7RN1
za%1&Idfp&lqhThc&Euy^*+eHe%ESFQoz(9JMICEm*i^yXp;NU(4)^BkwNmVUp!k5m
zjc>s;Dr>6TRNc81YsaW(UZ8`Xq{m-8eE6)35ysf&!DlPAW2lbqHPqUAhXz}P-rldm
z^`~~*voVvw2A54%Q>`@$wu2-|1ZOA2d1iTvg|4<2sQRJR6Mt^Q5RmYW^9~#h8#Zqt
zI=kef<i?wU{lwvl%vkZJ`nD#v<ORW)idtLnm@b>30N6jqfp8=~^hV+21D|Gs+P(vg
zfbZR=ND&FMA$Q`haeN6qz8Nj`e^t@^uX$|uf5gH+s1hiY`qzJ<O6JrrOtJ}^-NDEt
zJlS;U<3SOSJFi*wccDZK5rsUl2gQdX<3KDQw(v{p5qDx?@C~_P1c%=snkrWYCe2{D
zAdQgYzDkB_Ccgdl>4RfFfJQNeAifq<ELNx<_YKD*<){wYK>kA^1@`H9_NQT^y)tHk
zHm}q2-wB()%14Twf3F$iP3Co2!arFBBQI);dJi|XBmRoh$3^6hVtKWGXDw=HjYe)U
z%eqbjuU6Pmvb;#f1y6vVKdgD70Uk5tA05}}f(3BhosPGDU9Op!i2d&OK;rWYX0<AT
z(w;H7<r1#KmN0G<o5^*ft48wsJ(KUf`^m(hy$B121h&O%Ho;{Vc}$1T4=j^~Q`J*t
zBz~LiXj)_sF>&lceApq_<J&<USp=MbE=71!5R?t-c5%GjJJgf{34U8K!!Xsr<|#RH
zi9T^4wO9IhC~-eMy3Ez-R+lJW6Q3$P4<KkPP7FR`j6+v8xhNJU1fv^Xk*B3QQAt1y
zCRT=WDG*N6ETRNXH*pF&<x^t#4v@?ORGMMnmfxKQ0y9iWIW#dGWb^&2R`}|F9PvN-
zjl3HjA@V;O9CzfpKarO;g^=qGlhNd%*09eAK|-s~;!-j=hL}t`TT6|67)-0?7R-lE
zG=xU=#Z0J$t)w>v)1h_lh{9|#1G!fT$4gBD48TIW(hG0gpUEbrhp0nY&JhAIB9(8C
zrma+~#Y+>aG+Ecavr|N?pFObe4x!+E+dGl@M%3xMA1Q{f`)Pa0A77|AyjW#}fy;n)
z{>1%6x~ItHfI;|$Tr%47ad8~f1?uMZ-6<s&3)L>sF37PjALSkI>jDg%uQ54`nVI$0
za_*Lgv1Zt!qwCGDXbuF}FYuhbMv<`Q)$gF&EX{_Qxt`?JFb$mWq^S^vp^##5wVA6#
zUtgH=0{s)-=Ls_)U^L?Yh$BoMbryG@cll6I7bh}d!!gW$f8&gZ82rcW9Sh9X9wg@-
z2E~a!^CblVFeQMAvhRF1#o-Ya6UVrh>8VgqaV#(>J-YrR1t7qYfW&YO$U$9jq(cwH
zF;qq$FaRhx)YLv)^L)w53U_@NpX5+w=fpTDsV0SV-G)uo`-$C3fFx3vBOF7;75kZe
z;oAYKDjkr5$K@A6H@tf+n*=~S0qP*d@71_Fp9IB9ydcaC!$QH)=x+`Cu+&|g%vcFs
zlx|jO8A0u`Y+3rR@*qUm`@d1de=sg`Sgxz(pZ}nUp4ZhhTloclF|NJ9pu@{8AscKa
zgGLC()f<Z}N_#}^R4g7$q~aEgkXSMbrok&z)Na^QLMJdjFK$t%hC?J^F^jK-Di|(c
zv{et-4v|&|6WBR0U`bQSBum+ns+zH)gTV+WOPu=}bc^MLuO#{VDvPK{unbf9`;!Fk
zYB+@NlCu=^c(^dIaI`L=#<~5v)2Uwsu<cU(bGFy0sJjw*WMGMxqRNI9C4QuM`^iCl
z$P$&ID}4+y+g9(i*64!@UB*U*1=O>CP+y26DNt@e=PP;Nd?<<lpL~m4dYb#wdm#9h
zlLzFv8EVMwu^$)!N)@&}o>Tg09=jr}3BT-jaHIzl#ItsF<_tfy)Zw$biW%tB{w_rV
z9#4-ARrJr46BO&8o1JJx*z>zzAeeWX(V{OlSWpbl4@rv9Xc!)bYOpkH5ga}7fl!2V
z9}>k>#{z*1Vr0~yE@+H!sBUO@>PvCCF?K1O52A*<Yl=4%8Puu@PJrnIk+tLmp=(fu
zX(~oY&~_4*O*aYzQMRPz=tAk95moUb7YATM5an#gkrr_XaCV8FW$Tp>$rDhF<@qEo
zwFkMj5M>PbD67ASvY0$fQP}553-MI5%A<eR*PuXrg7UwR<^RUbHX*p#T6^dPr3iqo
zMlBfqAKXk_GAso0>MNNquJA)NAwS_wIP9uyIJJ_&7@w+XcQE;fSQoAO?XhGYK|ho7
zYtzXjt{}?BsjIz-2obf{qWol2u0)l%*Ovt;2~||Zh@NPI+ulO|VHT6x;hB=YYK{^K
z$xB!I&qa=$=bUbv){CLWp8M|}B3M@9?4poZnBtLxTahmkKRiupgTLFnF&Zd7rUzDr
z=WLt4OkQpc32h}RtA26@l_$UHL#^GM9WKg;6r%AjPybp4Id_~N=~|tmzq3Lo)4Q&c
z2o3nO^DUG3NwN#_Tw*Fd*-OFmx+_Wzoy@?Xctc*)1z!z0<N5wFkUgtGEdS395|z|q
zmp^3X!E*v=BS73WzZ*j9fV#m*92O9pBk+Noc}$a4gGo%%DT29_4!6R{{KUY)r2p!!
zCj5VeWGy+2+SWhmxS+>vn#Y3vpLC2w#G$u{MhuR4$3)s!>QEq^G))<RVyT+k9!<C*
zeAAq`*A>O4!l9@=TMEqP=j}Los4ENx$kLc#Aj}o_<}fl4ZaP_hrsu-KkGCL9q8bNd
zBxgjKPv*8-T97-;KgQCD!#AGZM#;oviTFifRQt*|?!!1eXFm@2luS@FV%;Ix65Y}Y
z`c3d*@CA_fhUFnBxRE@$Zo*hSZHptj4fh2ir?U&_pSqC)x#pf8R|e4ti;3}YMtAk*
zj53vaT7O>;o-2dlSb`wMvlsacEc5x4`oSblNJ6IT9gRo9cn~ZQa5K`pkFJTdMo)yS
z$Tp5wCYu!7zZ1sbXtrnI&H42pZbR7j&rOjcw$<8?WxMG4n=a<zzaZokaS;H9EPqf}
ziHulP48zjnHw+Ahp4*fHaHKEW3!v5o1&gC)vT1hKUX-Vj9{6!af`9>_?94@Zi6qSm
z$FCC4ac43M6NC{omZ-?19sM2)e;5n#FWiJcWCDpdZKoD!M8X%z9kDkTP+$gbc7++x
z#_e)4%h>C(JDV_mDliA+mLCXD)_!!5=YRw_%n$DPSA-4?<lL$Li|9psIVgZk4UmfX
z;EPMGLttD=c^^L3ECMtVcr2-K)va)PG&1FAzM4V;L_%J#{L4*=@F3DCzF@w@!VhQ+
z!g{jM!}$3CHf}Z)IcK9`8wcXu<f%S_PD3Dw1t3>%CTA_@ED-=RzQGQwE;EE<IZrJg
zL)s*9a{o!<F9(cZtL3^o9YrWwymzdEAIMQgI4;YUVxe6u59C-xj@jTgJw2`~`V0gw
zW^gkYeQLG;LIt+E-)h5a$rG`F5B<e$^_iR|&^zb0!Cg@y%kckU@4cd$?6&>kB!m=5
zAVBCXKxhgWdJ!d|cR~>X0YfjMqV%Q-9i@a`L<k+kf`APy6cH4pgQ%#XgIJKFh$#O@
z_ul8cV~=sh@antzu5*`XuC?a;wfS@0>Lu}x-0CHl3ayPg^m8yYcIW0LEN$P*cg`cH
zMBk>9lA)(Jd!%?PA{HA*;3{ih{ZI-C>fhd11fH5Ybz;T!Wr<(zxd-36BU#IK3Q5;u
zIZ>_IW%3`c$&A>}AVX>AkAqFiqu+QqPWrN(>=I8{tbkX9Jj~vFt7lDx^{D-lV{wF>
zP1UeS9Qs*sJQZroG>{!6H&fx<<TL5Y(QA`pp=oJ#JP=k)0YLr=baa@ghSfXA?>iGp
z50svXD4^T%;rVm1BnKZenVCe#0v9&vT-^;ugKvp+9E)@@Jgli(rElEX@^a*)d^+}M
z7tD_&5sD!}g|X(#uoOuhePivP&KRVq6E2`S&t;ed7pk7Gt77xH&;X+c;;tC~)kCfJ
z=TiQyDcSqCrX&T?KK~nRlIV_F_cq%8)(Je+h$VpfCC}YJ2<>xk6#y3*XNpQ$W3`)c
z`bl!)#?!+zAB*&M>nDlz?A6aN!L3diB5nDem$S&@O^GySe}%}Qo!xI)xFi-Yttj&Z
zP<%%^S(Gn>oIA)8Z&F{}cywr5UGaF*lUP}G{1F=eVgIogr(HGA{TNuFuZ4b^Dp~nu
z+eeQdeHdFk99!Xi<G6wl1wC}tET5DtGQQqm(aG3+d&-XObKZ-M?v(RY+^)DTj(4rK
zV%#F_eh2z#r5*<dfA}BG50d=0CMqmPD>xK)tPEDy*u4EEdOJtC*XO`HK4=f+`l`mW
zm)or3@7LUNaTuCv>{dMvbp2l47D_E|rST3F951-|!2r#@v0^yxdqZ%k6MphTRhDXz
z!&%hfpG432(1U2r2|Z*aod)k>&Sf3`p1zDiVGXJ2G~0&9g5n>dQb9^jT|+WdIy-_p
zNr0M>5qHDZa2N~=p6LO@nXt)Fq36w`ZZJ{@)#9wt1c%LG@PdQBkYcD^;d-n?ZUH2W
zoTKj#r2ZOu!WwFdFDoPr0KVOO19%?WBl!jRAm&mzbw^ttiVtPT=4pmeXqD+o@BQKQ
zoZ#g$F|rHh$n^lmO05v~RYTcd6@~#&82=4jp}zK=_=98shVE`($;T<bp{sEwgML2(
zEv}QUm7NH@)|x772)lXHG^Ts$Kv51O86jrSmhObU^z@?IiD+Vdu=~M6oX0chzVSsC
zGx2O0RzEZxiI#)AGw3vcz~n#0cc{(2atO26tfB=;GJ1iMFPS$Twk@;H#>eHD?kDT>
z`G0^&uTd%7_X5H=(jOdDU$o@J4AVC>k>DA--6?eyQ2v+xvI9D64>0$RJ$jaCvZCr&
z-{Dk^7u~2K@3i_ruQ-eM$>)1dG>W&H)@KNP3p9X5c59qaQ7oMCx8&ao)xG!T?Z7wB
zM5Q<DH2d8F<uA>j?tK~MbjF(wcRfE|&60R#%gajap#O+KXY$>}EPgn|h^Q)l_E|n_
zW{`OG@DVWN3eN!k*%Xf$?S-OA{t+jiM3C&(_86z$_vu_gJS#SpKg8dM^@ZH9ziNhJ
zoxqrdAVR^H;U3Es+6g8wvg5%BfnX{W6*@WWcJnfS9vn*uCXs{`=wsQkUpMU?t=_2l
z*qQan7+kP=i3K}^=WA!V`8`W`&MxALT_lPtfB>b)c)-%-4$#=No<(iw2!L~8mKnm>
zeg05UMvq^)`k(2axKm#ZbagK(V;@G17zz0k^=m{UUxAG;{#7?Y{zrNI8SZiLVCKKO
ziQpW*-ypSQX9AL6!+V=N3PbNH0U&iwJSmY)^K7ZC4L1v&McPzw66owb)KpN9i|l-Q
z5j=32yDg`WKaBZs#dRvpZq7JKQM3aaNkiaGTef@VnjLU9bsS41sQDRY3RYrx^YyEV
z?xXpi8Rj`VpN~6p3W_C;Jj)L-zN;tu%#29xa=(2p=CF@8|GZw8GUvCgSJ);eGjDzp
zpMTNm*LMyJj!n2atuH;R=(Wa+z6|kf+Fup#{ru(TiT*2k!(VYT11>cz2N>=O?Vo(#
zrfjwH{?b%mOv|$P-0pW31c8bYc}@qF;$X5bwr`dnG<t9Ub;cvaM7&6XRU-W7?)O!G
z2+PjY^axQdQo^v>`<YybW!$%(FhS?=BY7kUT!6_q#`?^t&<JaXnW2$voyc%L-@MV3
zN~@X~qDZ_Hr-fWu{j7E|h<7v<>eIwd=o|N+%jgFteE5Mbtzj4uhV+J#j0q5A=EOo3
zTomXRa&3&id*|ZEYvyyrV}ULKAKK(oXet@t^H&g#>z_y9->BsuQi{YWq!xscKK=G!
z%4bRaAk82H;H>Y7P8S7tHzspRnWvkMNIsznBi$LnBng8QjLGf&QOaKCoG1i31S{2L
zQY2|Gc-4t#;R(yLP3;rhGYj{N^aIMqivYmj+;IIi6ge?N&ecGhn|3g%E$0SXb<jfj
z%j5A_wyVn0_0;Bb!$l8K@}rFomn5`IX|;pyx`B(E3vYJvt{uNaMU%%~+&Bh^6~5M-
ze5Sta)x@G5)Yf~NhhOoz=>hlE?{8jI3W>Y+`wg1JvmR=#IPw}3cx?FQ#7FzZxp+8a
zY)$3o$`92bPR`kn-9}Og@Wys+%~L;jKC*=Wh<@{(a0=uSJ{jk>C%R3%JUjcMLEdlL
z_0T*ERGQd*)P^k{5?dYOeme7|->BSW%;Qd>YWa|-`04qCe0S*CJ7r-nkiZzfy_Qg{
zH|F2tN_!)?KtkNr0(P?A->w9rdi{F~Emz~n!>sUFsxb;7LIFYeBFB#%-N^H=g!2=K
zB$8-_tZnw{8*j474P75;%Zyvyme9RYymT&G-1u<O23?+0RoH)RvQRv<i6qmHlUge6
z89-X@6ZXbVT8aA)cj^g4h5VuM+-)Q%ez#$%5SmTttl|p=1ypB;QyR)lYJsU9k9TRP
zNxPD^QeT}T1jO|*Tmt{9O#V-#FA%7o|7eE(Tn5Y}rO8G4SfGh8h;qPVOHJ398c7=>
zI*D>%1H=U$P8rwwFCLH26O^d<zKVXM9BFNh1j#cs9R*UV1+l$f-svGUPPaY2o4fS1
zoOFnZZ)>T;GDycBjti<*s_x^=QA%nU39!0kSL~P{%)8Gi(X(Aly<J7&MTTQT6YIVF
zD=x^xEykidw=0fb^Z!wT-_O4`UU?|{)AKZ~Pp%hEeeCKvw(#X~TZVL~q<&}ctEYPo
z5Z`Gv&rw=-#9*#$%|<{CEzQ%R@5?PXn_KgU`}1RO1EYK&1}f^KioeYDWh;8k?rfzZ
zq%=&+#XNRkaD42;Uu#49@XyRg2_mvw`ac57h1BTF^m7lQzb?c*)7%^C-u<!t1^zeM
zk|^Mx6#w^({QI8_rlhj=|G8FY4kk^7N^Bo(s_ejUaVv%Pkt@{GBorJU*Pp2}NP11=
zxKC%)^cP?W#>f1dD@^jm42L~T23?2BKJ1pJQY}56XKqMJB8nw?@aKPSFZB1`D1T(F
zsIqT9b<+!a0TKdYQ)4@R_$Up*`h^j;-z1N_GrDgLP%AW?u^f;N$lGsN3Q>(*Q`yQu
zcE-LbEB$sRpp)}B+v*m5d%3%s%Bo)wd-K}DrQ_lzgMN2I%pPsnS!16UH~Wp78*oos
zMxXT=&+y@_c6+t8a;HdiNbJoIjo=$+<wb~0??3@4-18yqy3hx>{B2j{rDz2{MMas~
z14WsKUNk(~upRm_m$&t8b{b+-ZCk5Q{L_1L<H8+5S4}7j5G;ygQIWr06xfzF?raN_
zG%AaS8WHS|9}}#>A~8bv8Qt~ZWselm<f?v%sJ9#$4y-R60Af^9QOem`!!%dHQ<OOv
z7qh-9Lpz)Z$-smIx(_~-Gd|m3M{7>cvSb?ozzogebA-rG=kuL>8)^#leE(|XO8&3&
zKxaY@uD|*hESfYLOdtNk;3D~TVzq2u(K)b+j;?f*w+Ax-&}&z~4o`x`si;^Yvlkwr
zlnzKbXoYxL(G`LhH;JQo^YZ<qU&8w^wF7zk4#j)#!${fG>mB1zyuy9L?wa;x_nPnd
z`$jICXq&UH=A3wy?EL&foN#`Pb7Sb7UD#{;Yi?IUesn3e^Iv1O;fy{gzRdps*vMF7
z+%D<+Ti;LFGR}M{u;OyBl(X@wZ%fntBq93~V(&LwSEFt$dHfI-M5}t=4OumYp;CYc
zy?{fyQ$jxx-J5%QiU9eJK#RxQfBbz6*e7rLeI~|3!&V&5pTMqJKV*qOi&nyq51o6E
z0xZmib0YqN1JC>O5B~31LT13w1|1Io;<Tb0Kv0raTS(n00N>-k4DdYw10?lq&i;$1
zalG(B6{w({q|rrL+p`XLx$%a<>$`^A6qVX1#bVBHOPxmRNDOuH3*%2i0GR~8F4>8W
z3p6hg&u>%Mm)}z;f~b#eo0saGU}zM6x^L=Xq7Xiw+0fW){koEk&%t*~AY0Co%_wuL
zKjMH``?;MqiF(G-`d78sRMct&r%<7K%hxv+_F%YU@3B4ePj%KqG^m|gg6FQbqIGSM
z^p7!P36><Oub;l09iF=NZYsAya4mSo^nOgILZoq{`jSgSRf8z*l!*3;#aIKD&$5?y
zzEJKT(`-#aAKKoWeV2c6=vTY$w~dJeH=B|-+Vi+xU(Pzl{M&~fm#@9Bi{T#zrKw)Q
z1E{e!D#TK1<Ksk5oQw~h2u2hEU1i;ZG?RQ_3p?h#X=Tc7X)IdJZz%D`u)<b|RVzzZ
zb<%V$eJK$!2Nz{h*;R;qEc5g}P|JW2YIkEOQ-}!=2sWp1K6!S(B~s=}0pohVTaLox
z$tymEqI7yq!Qr^IArb&lbdpZBHFW+RQ_A?SFATs@ZZp5%4EoId2xg_k?=wO~!xt2T
zmV@2feYoUYS|c%+x>7{MZ|BMZ2(g=xriKF&NRFaO+nkN9%UO6{sBAkJ`%T%~h=Y?4
zPp5-rEz9&pxwp*LK-mV@b!yD$M2dB>-NnGW1Tv)c)Rzwv7QI$B$tc0F+ESe_?>gW+
zyFKl`nc|NkeYiy|5e2d%CH^JR49th&l6{`rMH@@|d%;CX=o?op9GPeci$Lo#F+*Hk
z5f)mkV5vI)Xi$W{Z3oK`x)u4OHD8`utnP-s!FraOJaqg~%$H9qa|OwoGxa4WU_;D(
z;*VTP1V--F-Z&QG#+>JveuFCgz#6vGnyp0#0sYb2DEOO~ZLz8BUpB4SX^f7NhhHS{
z?oJ91!o}6UPlfd33qz}h4ug}IE;)^T@3hwY$qaEl^s}fXIhG~Rk>QC5svJ;%p;h%v
zzLyE<@fjM4C^`X^z=8Q)als%6OoU8w9VQvM8wnCYG*9bmu*>?MKOMYIvm32&9kGrk
z6zL23XxkKw7*a_25Jfstxi2qZvAFO4EY(Ucu89PdN^j~cJv}JcS<1KT#a|>2R6;r5
zu6%vDD4nrXW_^xP55r?!>S3aU9opYbn%DnP34cf=Mhd66acK67PjBu=V5Ib0Cu<S_
z#W6r4Et5SThretiZ%1%RkuvNA4sQx%d$IzG<3QJ`Q_}qr68oLfqf{ycGc^viB|hDt
z=$D9|UYuT;fh4hW0wI)O2^y4BSQwVC<$z0)vX6(pGQ@)~+xu{&n>ugEJg(VOAujh^
z7jBOnFTL5=d(s|Sa_nAslwcuE<^0at!m-jDVvhn?&*`If!<&qd$v@?DJqM28F{s)J
z=r@m=rR1PgdLe61%T*x}+hG^uTh*qa#R05xHO^G=xW(r2@YlTGW}MsAIfrwHri*9H
z757v>acZCT>A%!X8*GmBU42%3uw&`dm#^REr+QAq&389L5xpaR;zNhq23HWJ-@AFK
z`Fj2jw|IucjO*to54xFAJMe&Bjw&`BbQZ+_baRw7id!)ZtdGRfsR&U?Ts#ye(nRy#
zfco$l@#SN4VM0Ok^b1@IhFBZbhP>Hy-R4LyOQE0mAzcGLGkmthEhj8VMBpY$g={P@
zt<ojX*_oxA)X@q1Ba(0r7wkj`(dQ*?exs8mf!9}j;i9pW#bVvgZE!kp^uc95C4coc
z-UGh&|F8gmG?64u;ne5Hw*TnM=c6vH*)RdhkVmQX+px#uG+t%T@xCT0!>Aj4iP$JQ
z-XvFC-o@K_xaMiD{LxXoKToY;F;-usdX3VVP{L*ro-W5uN<HuWD-Kr#26LG<Zi`Up
z$}9afaz`9@3n@5O<X~G*OP#f_IHzEAJgfF370#wyzp(1}N$6qRhi2Snw5sReO+iA_
z^5f5M>j)07nqF&OGl6y;UUAf2ryw=s7Nc7uNuE=O;w+R-D=6FuKpf`nRVd0iQ2rob
zyxwiK_QvtR0Sf0)!(1G@UhGzmY*z2}w_FqE;!i|=WJTu3eaiz&KEB*u!FRSMWvRy6
zmF;0nFB{&eoJj?9%mBidJ!+rYunA^a4`+mqWX|5x;1l9ZWuzS5(Hb+u7nVZMYI?+P
z`H@{eb74^a>S6YSzt+5L4*%K?$>8K}t}Q-bMP_!gA}N&vYSXTB1Io1BJ1)K|N2+Iu
zM?`}SgpNc4+Beb1FX$fZp@cCqiqgkJT_3r{V<)WaUE`r*^^`|--EiKgkn*gG9WoxU
zLRI)f8TKiJq&n%07{;>*k2?c~17^Sy3{Sp;xA-lLWW;mp)U)E{R+g-JrF8(n$ry-0
zKIa&?;v_)_0H^%FLKB|;xdQ$nn_+fvBJofEg+gvzp*3P=f13{U6v$dbfKG~89abO7
z<<-f_r4=13z*P#%kwI5F+~bzK9Vn&vM7P+^y|-keV<z$524$#ROv1dC*t%?4zW?1z
zkt;3rDRriz@zpM8Whd*+JC(1!-;|q*(hT|4PTAT|t_XZtP*dExFm)dLs)V(qpxX6D
z%xc%QKFI|4HkXf%yX*pAOj=#9xuZ)X*Yw2Gt=g`&kAL>4k8R-lRl0T4r@Q)~FS^lD
z#c?9vNaN%Oo=S&_V`c-H-^c4dN8MVWbx*piC+qjq<&O`FOet}T_PL1OtcXrTzi2!y
zaOQyloO?9FSo#j7g5~=<fWX2}-`xKh7{iGvpB^M6bBMoMjnE5zw0C~}?-VnW|M*M)
z%w!a{{{?80_+tOiJ>j4E0Dz{63`O%Ah*{R3@#@Wz*zZ1YH+xPuRnA_>u)fLXNue0&
zSu29W%Pd99E4mLyi%(?5>WU=cg1w&?$cDN1buRRk*d4(nYS%1LQ}XrPx}avQ-0f%H
zzYnnYy<Vp6%3YfLKs&rX(f-%w!t0BtkKd1b&rQ80IB`n;{EO!F_xz{radBIx`lLnj
zt|oR5Lh8S0o&s~lZrx8^e##x_)BUTID|PP1F|f?mhc|*&IcMD}i;jL<^#z#)5v$@}
z4W_w-mA-j!e(YS}y4t7lwx}Ps;ia3?T|*gC<?at|ue^?^5WiV?eR?N2Pmo)rOoo}M
z7si@5KW5_peQQjNyOlP%Lge+ki=%fFdV{%K1D;O+qHq+JN=0yEgFE2-A{3&l+M7D2
zwN>#q(K909rgm2NK`9$Uous08-H&}<vlo@xBCW0W5|?R+4qVk-rmmy`N`%{g%_c*_
z80edXMH=uqW|_ozy5U(<eK?<kSxvrU4q=|Iac<29ZXb@TEwT?}E)@9J%9Bfu0Va}5
zL4T(#od3t?{nw)jM+<2z=K#KIKv}r-oJE$?>9+|%NG+8tVUUIqwhn>^B_yW{Ys<JI
zRH_Xx@Ev4Wnl(vTq$ruV>=JSpJM-6F^kbdRBv@t~J_+m54)yFon83~HO<&>@*~F5J
z#|3G1#!BuuZ=9(Ff?tYl>DHKeYqcetn0}F}rhJbRCwpm6qk5uGcPXKwGOsa9ID=hG
z0OProWe0T&EI!3*(!81?az=Az4DRy*?6)&j5hb#D+P=tG)fWM-dVAPiS*dz?ai{=2
z${~G+clY#FsQ>otmea7j*drZ|(d%gWoOSC7mhR~}lU~rRxEHnfZ;h`TjxCE}iuT4{
z3|Q!#&pqta7Z|-hRu!Q=+~zk_{2<1a`)c~Yu8+@+h$Om!?#@(8mNLm<7##Da0``t5
zfg?Wm?R5j_ZK+`RR17mJ7%cwfgBJ%D6WfII?gvk19^elvqH%uMv^NhDDs^&6u<^i?
z5m<aM@c>Mxvx6k?cHHeCzUH<RR|LpYM9m22>**qSQeccyI6lXzS2^KbWk|VD?U-Ym
z6l|tB?HbYtk8mrh(6wNdUeXQb?tV=~l4rWX$mxa7ykY>$XC(5mS;`v!tg3ei7Tl!4
zv;dnbEYD7eR8we7jIX@7qef5Ta~dYqS0?KO!Y`fOhq057V}h?#hV$Z9>w$JR`^w$s
zl2tv4@%JaL-2JOdcMT{ZiGN@XO$?~&>;DkK>zNJ!*6<s`<<;=Mi;>J`6IZy92ZCSf
zN)kS3e3eeBHiG+hU7p^yUg)JOv3IF8C@&mLB@q|#+cdmQ9>@9X18bkVfR(Kxd8I33
zQhn!5g4@!Cas%xcM^Aod5FFmymh6*O`Ds$I;8>&*b1pw(<DDMNCL(&FUTrz$y!!Mh
z^|m{;cDEwdI5KpOC>?JUuO~)6Q&$@8UElr1Q#uwj)2bkEm;A$d#R`azUk(crxH{RB
z=$x=vn)~JDmC&Tx>#ncD0%>r?DxbTXcT$)&?|de$1iwE`65>}n?{>-CHEN^j#L&Z>
zXltZfqJ)94%|qR0A3YhNy<v&2WG>;^_J~KF4-y`QXGAnnJoL`*{R|_<yM0e{yyPZ|
zuV+w2W2xdaj0;qPCQhf!P<dYQ{*4{v*MFZ`Tqj1j^1;8vq3AnlE`RJGVi;qu?Iy3^
zt&jWoRFg+<(&wuW^f6tPeF<D|X{u2<6@~>$$9>Zo^xEF2ea`O{1mb0TbJ=MZF3@vv
z3Bb}_*HrWMWt%iCTE?_#8C$}lmPcHs(<^LJfX-<kSdvpS{Oh<?yT&Q|i$$v0GH9WA
z98~<n_Lp`(t#^mrH6#^OFXmO;s*yM_kD0vjR#@re^@XvNM%ddH|0R!GauOE0vBMlh
z3IQhWH*{#L_7<YE|8PvB7^<3L^G<Qf@%*|dV#eZ8WHte%W_v(fNzgbU<=lV+<;=M)
zB{PA(in51p>d(ygY;;Pr3S+;eO9+_Gi7oM$`#cg>r0eIN*m<(0MWq(54qi}p9E-)F
z^GIyjn+aJeRRcLgzIX5A#Qa;h3_IDM&d&`cFK&igu=8jbQyigYAn<{wa$YEjFUu`R
zjuBfePg9mSdKZWVLjZAo`!L6f6z)?iv%)!t(m1b*aKnX@)v9cC6|uKQ=#{)$bm)-}
zb2hq*Yb`bMwom#-ijL&SO>hnR=W-l;Lsqqb2;ve8bT@_rWDVY49p@(T<2v+(<GnlI
z5k(DgKw2+f!g6IQhiV@LuNKxB_?j2$4Hfoo1J_>iy%12%tG;Ci=gTv{!de&3cn`0L
zCeB%i#|i+#4pD${xpoH-(==9m4J6;_fC&fv6$;A^`7dIQ(#e`K|KM03FgQmI8Pm6M
z!vJH;g?M`DMbnHyfRqmT{xS`cgn~-p=cmrhbo*%;Ix0lcjO&iM;3=*zN2MRrrO^7s
zs*~^VP;uS*>8Xu3CJa@iic{|3I~nM~;;*rSs&bv|I-j-l^(FTA7aXXl6e*HO&5<G(
zG&!|z2KCmd*k3hbri<P?vxtx;yv}R16pX33d9m<@xXe}as8c`X*ZF2?*k*vby?$J}
zFN}SN#rgX>5rMcLyn%92aY=PM)9DnWW2HHnC~K1UJ^nTvar=zP<W9*Zy#FEXUF~?u
zw%b%qF5Iu|$JVF0LOnc@g6j`7VZkUo?pvOo^RM3{o8Jvt;Z_RU%`tjEpOVN}=cuqR
zT?K=0#qC0;IQ4#PR%HmpGMC1}_Ldh&kUMfx6)I0nmr+V~+Z7D^r8KOuomgzgWiY<L
zAFv)?-K2-P)tKav!me#khsodf$LI?mdOUJLCw?>QsK&mYR9#_S?X2t#Czd00yPp4y
zOYP~z5k1=nrtwhW(3OQksUQp>&ZGp$<o+3#PPi~@OGN1bG6hf{=V3#kc{4y$Uj5Xs
z*!Qn4>i-jW7XnJ*pSU}jk<4cH2PJz8q_=b?y`E#f`!`Akm~2zHx*J}u0UrK%;VL=r
z?GY)hs1v3oB1I$!YaZh0?NIr%3CYEP#`4}{+0KqU9r3nA`CJNw_@jQ|E`=a#Sfe1F
zxhoGW?`BEdJ=5OVAv4-&E~T<iLNn%-uinYdt?IGhg^A?WUY1psISS34ZMazYxvZ^w
zdQ^*?#)p5G#$g_98tm_?8MgDOcva)mD=fRHpeOp?)@+hUxW#v2lN1X<CHZ{>z6alY
zET4)g5eOJlg>)ziCsO)A^@PoJ7Jd=#)r2cg?q?M4uwE&>x6#rn`fbZBPWw&+tio@0
z$&Bkx$NM)W)3MgEn{%Usvcm6suXBT;h<$yNjh6$=)^b;9S%+VQjy}a}JE@nQsk!Ch
zKsJGfWa<6d^coW4Zaw<iMLZZx19Wu6g#FL(RRaWjIVV@sF*6XB6(N9|19ST`at!t#
zb`&GaqU$i3w?uorj7`<O@fLw^H1NizPgS#W$%ntsYlj3!aFfJ?sVs!P-=)xwkxI7N
zbJZrBX&E+kmIU6uw^+gv3b;^xO0)sqZ$7QAEIJ(L2M;ZCkWCd2N~|kCmqP&~&yKDv
zSJ92l{SbHuHh)C+UloeXpR3`2Rq}Ku9QtVfKdQ?P2?M|Y1<cl*zaa3D89?4~!L~K^
zOQms?=pm(8S>^cT^U_w54t-?cMqqb;qEMghWtD|G^M1PcjITN4b7B{M-`c$SC9{hQ
zyLa;ZhpITMtbaz(R?M!V6U^hBYZ@ntZL;@WYuk7~bk$syu(h^z(&?JPgUVa&b}O!J
zh`1{s4i=m|Ru$W0{c}}K+5LLR8xF_a_44T!B(Q;^<jIGb#DE#T!CCEE@A?x`Qe`4%
zBoW=UM_)soi<D<G?~<$sVr~mOdxuL%a5d%%A3#*5N*n`1*l!-aD0n)xsX{00{X|Pd
zy=DH29vbi*;1LJPcDFh3I%M_CF9|Vdq0yAjMDbrcKUUeh9%t!6)AqJm|AvoI`|lG5
z_zt8702Rb<1J7rX!>xQZUB6FQY##wK*p&>RRn<-;77`nlkcf*slVFm}E&e2tucq6G
zlixp<J9!aok$8ZlpKi9km_T^(HBP@{G@(CB+30X}fIX8%<<)M!r_LJ1q+TLzQf+1C
z{jGB~9J;1N3B!Jdt(Ud%iTnZe^ZDFFp_&C6ltD?!ylOi6;qb{9vlI3a9}tN*2;CgF
z*KVA$i~HWzuv&Q9DL#?rqhB33uA~=pw>DUCG0UwA5iD&}eQfgjBVQ6mfZ2WO-A%|%
zR=v{K6-_6PT1xoS7CD7z%u2t))~j1oIMO6X9WLhb{@{hYhPrPLG7VpbFTXXjf0U0i
zh*ufk(Vi1?-i~<X`@@ahpo3T)vyJcqMW3DVb2&T=gifpf3U29vu}$#5i5tsLGS>XX
zY{@$OV;kW9Scx*@iOeI5V3@^l<$z)*IV3~1#C5pS{$pgJyOm}Xk#-7>3x@J@i%_yt
z&pa5jK8QV%pAE%$GqUZWLTTPc+P>Zx3KwmhPL_80K4uRXeHM$*ig{=cnP~Z8gagn`
zUkc`9kyUv(wKjA)kOK=S?0}<Jeh%`=4=Nf;^(zzlSp^6yfo{4gQ^Q;zj-QT_tAqy-
z0xFWMuQb#!l1pmgmB1|4Q2F++AT8p59lIt*3VPsABmG-LC8@aW2N?Faki0rUh%<K3
z3s^-y!}{QvClR807p|t>oHxr`*Nt~IYpQvYD{nA*zi4FsNvT*U+kKowLJB*Q&vcD4
zR@Ysse<)U~Yk?KQS7dy~qiLqtqEuP$R}6vP#TED_Sbml7M%g_(t>}k|J45wwHuBWU
zSbvtA?)kylb3X;YmbaNAp|e(n2g+|BJn;$?h~Jj+DBjBvC8K&uA4a?K5lrb+qp^EQ
zdp}h>oG*Jpq1vUei&0@GVh3^Qc^1b$yvIaT)VCJ~1z5c;j1vcCMr<q3>B9A_ex42q
zUK(Z{w7#x$@zd(JGXB!(!)~>;=f$;N%+)Czw4YzlJ3AajOTFP;D3_ixbhGIVjUTXI
zdj2qbQ7(t5=Fc~s-_m?)cu@3cjxiR(TM<6g$1;*E6fTz~$I}o#gSd(FnoX0FY)KbK
z)!(KViPABh2&o{77XU%|&mp(~O=K$9uQ3{{feR7X<;86le~~zfjfaUEYFFneD*>dP
zzDJrE(jvK|Cg1X}E>N3)e93?N8K9Ma)NnKHQ5#o|ga9~{QGx*6xUV|60(elX!j>tv
z6ypRgZv9;Z_oY4#yi%D$QL~gq>O`fp0N2>OWroPnbBW8NU}VnW^OM;37|FYSQj}*R
zeVv{0tQ<O+Y5$Pr_DT~)-?g<FDw=e~`1uT-SY@7NC1s8Jk!6(3`mF6{%TXJ*JEkHk
z!9K5s8>~g}6+L~yxUxslFZw>N9_1XS)daIYYT;8nF@zQ4X2!SHvK1bDwJU${Ec4^@
zC?<!LXpuw;7>u-|_)mUzxdgfX;H;S0dKZz6bV@$KI76sC?#(vnvykTPBo1CH8FKhg
zIlxzZ__(LKltNs)TUuql1@g#!aITA>eu2fRT$?zCR1Mu30MBwlBsww<&xv>tAt2Nk
zXH>_^op-uQZkoc7xep;|E;zO$NrSy0!rh~3<?)yiQY)A9aHplpQ}vznly@mVPEHEC
ziIInmHGgg<*yw#9?*>9ticCaPCndsdo#}ERfZX=6$_3?zi6gJ*${d<Gmg2Y$Y5+=v
z+5v`}VmkFOK3^GOQZo5qC??&ACmmN~GG}ut|K8~3CK4-;S!m#9mM$BsP8MTkK>b)b
z7q%ItlCJT7S?Q6hChuh#fWfE{Hl(lAN*Q80O%H8p59<L)W?(~|dxV>fblMI;`-<=y
zO`A4CoJOxfrNdUQiPM?;8{7Y?gk1meV*I;=P@41qaRA=w%>Ls56vF_P7|iVblQAL=
zk0Wip+9S{hD|Znl)kZl$@Q39~WzW8Bg4e0)72C@GQXQN1Q2&jk4t8!OAl-usPN50;
zU2$FEkxdkK_rxRY_vK_j#VgM`IEUhsa1W<Q_D`;h9Sl5&FEZ3t_w3KclxVFMes;ef
z`E%1&6&EfyacK{4N*=vhe#qz8E9h$Psf*BJuM^GKd&!-%zQ68X)233a9z_-k05s0G
zIjcj+!#@(f;#gSJzQ4a`PJP+rR(MnJhrKUge^UASVPy6}i@Is{x%dRf@D8oB3j@x%
zZ(MD6*53E#9(eTmqsYyO_o7{1vX34FhQ3^$$SSOJ+Xz8Zxrt=R^YWJ2J1bS3N&{vS
zZ{1vpL=wj(tpqcO7?2pD`~-CNNXSQtuQWJ64lsHO8v~s=a$w=L?#%R-owdwuJ`PVJ
zDIa5tKJyrJVc(OYk-+tVvAHbGG8V6N!6_n2r3Y6vpJT!81vA>eI1Wf=9e{KXKx-Wj
z6W`^Lw){<B7I_uO`xd!JH&np^#Z>1dd?=`{^ki*7T?y-(hNUw1zxvpL|M=LyLDt_i
zweY#8|MK^u05`AZ{;o%ytg6vkT9rkBOiC)A<xan(aRyX9RN%|1muWWEs?su`qN<;c
zHYvET6~au(R}_3WAeienl(GMi@niYy>Vb5un1X3A$-t@xC&7KqKNOJBT1oa)Vx?#-
z1?xf_C)+lvi5wQc6F?4#-E+|kQkvLzv;G*TPV2&I-KP?r^Ka_$4(*P0W&l!GO0KmL
zuT^syrp!u16}=wv+&f2QN_3~id@rq`fFx*eDV$T=K*`vO5iGlWxxY7wlFWAWbo|$g
zub~yO-&MR#k!m0PvTy4#IY{uR%y`E$tym8G%~0`n3He!mQyPus<Ho2)X68YI3z6UN
z@{*`bVwRfR=HYjN+;`wymp*i7sa!T}PE#3_yZy#u_|`%>93cWU;6J9iv-Dob-6Scq
ze|%Bs&yB%@6`zv3(dy3x*5iXXeI^)Y=Y4{SV3TSZ6oMQd&k3<i`s!fJO~6!|YpBml
zo_BlheIy&;MrX2Ae~xGC1{^7NH*mNemIv26i340uiSmm@k6pPt;d{Fw<2G7aO`Vs5
zjWJ6wE+8|hB=9ScnY8BwsApqbn*89Rbf7&j;Wh87#G_s<SEU&5Td9srCd!rkT>~Bt
z)Wd(st>5(kG~kGsu73+ZnDafuYoCw*Zop++f7_mdKc4dMTcc4BY}_iYyB!qH+exT{
z`gy&c-exp@-*j$Am_DgMSo_(oz~~|o;c@*-dm_`%B1vET;YEQeNKchl>-UZEai)Ed
z=sOZrHV5x`@~4(WB)x-X&LDf4pEQ|Ve8et>^9G(+VwwFpQ#_U3anT`4b02+oX)fOV
z<PQeP>uA>H78TS(<CBP+{z;sBwWg8xIo}-$|F*NTdW6{GIw-zSGraa)oSQA{`$W~P
z1rD|I<LL^B9hVQiZTPI}zO}pJYI1PY-Srn%L*Q8t!BNE@wD@Pezg$UseN^h$;gF2$
zz0c3x-M8HGOG9*x3bH>OMjz+@3h0CVwlAq2c^CKHL({>qC1Z0a!nsD85x2c^r}zvL
z2NyyQeC*+k!|>fL^LQOsK=Q9rpL&`AHFpv*aCo_u1x3-7Gxe$wQ)YTwWKSw>H_7{m
z5xZS*qT=9mHqf^|u1G%+fa{P7;+kkJG8ZFLi6^9QdIR>Ty9I7RJZ?!N=I&xndCp!s
zw^DQo%8y6%Kblr|ng(1!@?MG@Opx`|n{=i_eNq2HWl<_}<BNVIsh}pHT|9-MRplBF
zgN=9<&4KAHIFMAw2*>U7C;GN6!|Q)X3N_|1I%|aJ>@M%G61fdmuig2pizNOZh4a5@
ze2D^Jj_LcqO&aM%iaZb+3umCEfG5k{RE(_ov@ciHlMJ>)Iw<*dHzTMxv`n{eM5?cV
z%S>_@7vkGlf)<|*4N&$qE*GP|ecWJgkWvMc$2+azpu_nF$Deoy(;*P)T!$WIki<f7
zgo2UAPuWGe1cBi`fF8|s5oQxjsJ&c2Q4NQgwyvzc_*n8VZZ4DAlor1H>bwcwl|gDe
zu50OXWxJtn=%wca=Zl_}pqY#J;$FGbPgW?DKj2IMmf703QC`K01QL|_PYbCBzUW&S
z(=@Chmje57yWHx;A4U&X^m_Gje06@Q9l-8d#^BJ4>D|Wc3fUY!;5c8IKX<BXNbCRv
zIV-D0VQzdc$SSlbI*V4%U_n5gjD(^TC+yDl`{4BPyYp2jne3ohHnlRrls5;ntbRK%
zHVKx8etiJ)o_=kzWQ4&k<W1{wVm3kW%W|q{%@<m#>0)0+Q_903zqObM5saab0~yE^
zVtp^iWq9Cw4cG5XAu!488H~$}U2DZ&zq~?vypYqQVZqY%)S5Mr4U)T968LP+O2#=;
z+aAHa3qh$wE&|bPk!)jd7MrIHwg|Bx$})@#7hPYGmV>Eh2!;L06fzH};nQW4Hy6^{
zw^Ap%=8ZM3E(i>45T^rpz?A}_zX6fy|EQEdydEP3kv;z(%Wdw-e;GEoWaI%}Z${r&
zSk2+Szw+FZOtB@iYSZTGCrNS=gI*f?-WCZm9+j?<LES0Yn#vD<BZDn;BD<Yw6ONXM
zf`o9#37nZtIS)ho-&0%V5kjI4n`V5!xtO9UfH+JxR(ks&`h9JU2O)gvewp5$2X7yx
z;K8{s^#QN%+~A6DGg=bmZTM!0;6yz6nDC^ItxzYg-jry0q~^#21u-c~?~ouI0>c3L
z-7h_ypX|91t%z2~b^SXDm$iatnB?Y&IQO50v&yW%jQQK)^$Ku!xzxGpipW9KE+vM|
zEgg7!nU%}%@@{MU`g?FZ5||T7DFr&`8|84@Ckt!)6#R|dBR7B;F|dy79OnT=oSM65
zB)Tx3h_sxukj=LAwA9@VT_;Au!;LSyv+Dy1j=R&q^4Fho8&K%zQ-`;DQR$EW$MdxT
zg?Nq>7R8B+G!?=R@i7gAj^C$(pjTI>iVdTFY60m}1R|I;s;HLhOtO_P%SUy3OPgx=
z$YUV+eO1H78w~j&Ro@k98J2{988*^T3LJ?Hen)F}EClvjOT!R0Brn5gz@37OX%ig(
z<M*r1u`^$(%=j9><(L!BT&XM1p$60zbF?0<0yy>eSFYszRi%^zmGU2c=T9dJkm|f`
z)c<jCu-Ezg%fYdWtGIYS1^3RVRKT~pC!JMWi%y@x!ILB;1{?W4rJJS01Q}<-FS4<6
ziX3_ps-;pY$gvm9J%FpQ*9*zz2E`#y)tjcx+;(yR0_T!!e@(gN2yM;{SGw5nZL&Ek
zyv#f@1Z<7wse#}2=!Jar*YF*wGW$5|b7w`-@*dCFS<xa&?xSeiZ)`@TVU2E_*i6Ee
zkooxeyXTf(Ih>#a{%<|$Z|Lv*E1ntf84c9sDV3lEarf)6w8^h0<4K**eHGhI^}n;1
z9n*NPljJwwnX>WZ%J#c2@9yRE+^`aA3%aLf^5|Uh<+wWoY1H1+d2h(kr_t}vY)HQs
zJ5j{7b|Ba9-9x>}&7EsYfHfB5Poc3Uha5lG$Mu-R{TOGDQo%Z!N)R5CB}j-pDB?BX
zq`=Ll;!go{C_Z$`BY~yHp9DYf#GjN7*lsE>D7c4a!*m0ONf~;9!E+gp&;j$=qJMS&
z|DO==|Nq0^FQ>c;6#T#Pkq`ZEJ~Gcf*S<AzARk%E+;Ta%vge`z(s7{g=3G~Xn8Afj
z(AnyzIo!4yyLCB|{RQyj&53e<6^pzdWDep6l-eM~E6`rRHsEIOOn~mm@5)v{peY>U
z=COCz#7i#<sJg4=CMI-Y*5_$Ff@iDmhp%5ZGan|+v=?r?>P*x=eM|x_;W8Mbd1Gm?
z{Lo2b+{}8-NEPYy?cIo0`Joc?G#w+h2@<@)KHydB1@#kl*DYHPzlm1A`r?XDPi977
z`1=>Fp6|lLE{0#XzjyNU<n!0q8!nH|eEY>KQgrprL$W4j!9v}&qJnK9Dc2G(^F_VG
zJOBJf%3B&@=v{g_JY$fGsJE|sOMlhrNfXj>q91y#|8bNzBxRdla_Q4F_;0eR{=X>C
z-~Y8E%k%$DB&BqoNBsV*O#lP~eAZIao4-Hn|Fv4wA_L~d9sA#_McG7Ok!wei#1CWK
zo?)wCHC*aym*3m&n`pGU<_WA8Jz-Qu;qtvpmPmNfqF-)4e&O~<z1yeet_+YXu1>c{
zCU97?ePz<+Y?DKQ^ix9wM+$Pu4fTaE%atZ5xd<xmrsQTyX)bg)D=$9I<Fqdo>AKoe
zU2m)ED^v-ih$aim#9hoLtTYsJ-FW+R!r%?N;EwM$E=};JDVMGd%A+zlQ}9{T4Gv`k
z6ZDe0H6h63XLJVNh(Yom^VgyK<aI@|%D3y?JC8Y+pC1%CcITYi*ywp*#FylkDmKCc
zNBLa))%`9b@AeeFi$@E>oUmH4ph;GRU42g79vo4?0VA!h&)0_CFvs!|?oP3qrP>V~
zQ1}H&VL_e=?h@O7yXYxGW@Z?Eu{g*S3s=MflaNdz;h3peQj_6Dh4-V~2ysji7N%p`
z>?y(7*E@_c(_Qw#8qNAuT8TSQ4Wu`(ZdgK5g2~+&S^pI}ObSy`sSr%2VrYjdwE8Z@
zr8B_gUMhSL*ra!em4qZzc8pbV8DgU?xFcX|CoIxzrTy~545%XMtTavVc}K!v!$N92
z5so-R?B4&Wbnn8T=5wg29ZY?oc~EnR$(STx=d&Nw9EqjiQ^cj6`!wHORbADzLtIeM
zH#>yuQTY_R(GS6r$f@e@B6FW>zKq;JtNKj|1zP#c;>=41n(mPivfi_OIK|X^lPQ;c
zrP!b`9MUBI#~mBbm4s1k*Fz=9O=z7})3f?;W3W7XON$}n^Zg4RItY!`AizoP*yCs$
znp|vo%})N{yz{eXqDa+~oX>Z&o{5Bbx9Dq#7n7fs-JEE#!zy%IYP>8}ZM<^zR|pAJ
z>DrQ^xm3D=^1j3Ig<WTfkdR=g%3?J-EHd7-r9CqJVK_)pv%d7HL{qlhgsaKwhQ5?*
zd!}Z-^&XTYGpTiKt6|l219nI7*7Gle$cn4mdO>rpmpnBr-rg-$(tC)h&SvC3C#<he
z_iDErcan^3GbymX*Qs5^F<a$K%s@nUTu7wKerpnc|J4v{Wn@d~_vAj~>)*R{McdFT
z+#!@a4_6uG#8Yh9AYP==_4_pZ)z8^fyC)YY*+`jCA_S?KE3Vov<KH_BN0gm*`igw&
ziuZt)>9y~)q)-pr6@{e!8a2@?`~LZSL=}415_h=dIk5K7;9a&cAs*c!AvEY&qAynj
zb=&?F2!3n|OKxJjzO@f3xqUog8{Qf)F_gq3A^tPR?skh&H-W_g@tRHR2JCRtd95jT
zt-UM0$!NosILW?apYMOUIBW!k<TSx1u7q=h7_p!^oBBY-2@H)h*(nH#^6$gFrOO`(
ziOtFd$SD)OZag72x9T_tmp(*<2_hKCW#}7H6ST-5g>4DqM!Ky!p+QnS+*;*qVOqlI
zwbK$)_QyY_8xp5UHF2!dqRO%G`<zrz`uObZO@Z&6g7Mr@I<{}MpONrOyouIE)C2{e
zmq}wc71>%JlO)`25h6kUP;qua5e-bdQr{>_Rm;s#pUUDqi{r`JwvaL8V!iq%2x?1z
zykErw)+dn6Vn9t0v>WeNN|odZkG*iIjgEA8+&F<0BypY%fZ3)(IHU+9>>zG$aLT)*
zD0o?)Jx?&7YaCbjA+|>>)=WU8-uhAwl^n$2h6DxLS8yCj7o7<nvBc9VkS~b>l^z82
zFH4B%E-q7`672hmtD0A^0-e$XcVEmt%li>x_->^YpQ?(C2@Fu435JOT4V;uRUEYr$
zVHGLOWYLg=y{M!ml<;{Xq{trD5$~U$_XfeAs2Ol-QCVdBauCLEIN|s&gwsV}7W(Qt
zL=G-3X8qLZxMLh}4SHJe)o!5}T<wBTC0Jw`SE!zE$c@Rx2l44++b}(1#?1apqT?t7
zjFI+G)YwbuTbH>$zCT-nOz|^TWgAO}!1M`F)m`j$snBbJp`e<Dy+qKhZ_q}CfMYVQ
zgWMd}^(XCuJ8W!G*D?3<Qd63#XoCy0#gzmDow=1)qcR?aTn{=v<}|@=@5dMBB^95(
zRN|C!wvSMr@qut=nD$2Tra;@{df|*7OI4}{GH>Cf-=ltqkxG?(0Vnsz)=cwwe;lM)
zpy1xKn-^I`*nzF_toO=pW&~eugmpi~t}=r`HVTpaI@A+}mcfX#M~aTh4jK#KG4bql
zg6sKMV*#-auqa+jn0N4r>cAHI1ZA7W!Sjjcl_yuNP$Zi@28he^W}}~JzVmAVLqw(T
zb=og4@DPPhITJTqKhEIpZhmqgdElyf>_><#W?j4Q{zYl%fxV};sjMxjK^X_Hwz7{o
zwIn?PqqwE#!G0Y$9m}>lHav-MU;cBLBnjpFp$mm->O**S-U_57INx8VsVI{ZJO_%M
zn-OOqY%`eweeuT<W<jWeFX+I~nR--q2X~^6QizX~!QL|U<vur$5alYkRfsa-@K3aJ
z6EhT}m7vylD-B^-Avm97RH)qH7#i7q3hPD`?@*r)R5)|YUu^(p2v!M#evM2-(^8_O
zjeN}v*tpl;BOGt;7yIVKjl4_c(6!|_Js;US&<sOcr$~B@mpJzk_3wKvBji*sb`3mB
z=96rK`xka|1({Rvts`@!`u&nZGODT_M=}iznJmb?zQ;{{TNz$`jg|&Qs=SS+jY@g-
z20~Lri90mZ>G4<m4+AH}7+lvqsr|wWL}MNtA>RDMv#z&I#?m=sG`@7f9zJVhZ0kij
zyomICQNLH2*#WY;ZXhyYs;r_EtiXW<Go#CluykDlGFRL6Zt(2+GnLQ4{E;|#fzj=|
zw=>PH%;0tlC8MdX2<XYIu&=yu9p=r8*KDBh6sP;M{G3@NCWu93JLz*7tFkZF77pyI
zd7&|M>vYEqK`IiK&HISMHZ>VyyUnUwU%zuYXbux1s-lA*iNEhLC$cGLh@gC<bEcEA
z?Mn~d@25@hId}z!xc44d<nWeEE$h4T?#Z5X`ZidVaB;Ib#t3a)2PWoj3MVF)R&brX
zmH(cw)K_1k`4zKL6lnFO&Q5)m85ODw>0=(eQm6JR1<X!Hw5OoB$bzu2*q1l~9xiYt
zQ=u+CppOo^SIgpO;0<v?eD4Bt4<D2?)oCUGq9<@L4(+#u9F##X<2d$D5&6j{Pf05l
zar;-nsg|uE|2!-^2zidx2?a6;NMyM|Gy+F*tkIDMM1HL%c34$(;!(6w9<+>k@M4`>
z<535JV2D7q+S1X;f)^6vYnGtpMDlVJR}=dxh_i2)m6Obp)6CJ2k?DU74yK@|OpI3P
zNZG=(H&wh>F$c!&zy<_`t9vgLo>M{!*TLeWt_f9<Z`asf8h~Rc=u5o{YfUI}2S|&+
zc63U?JOS-bfDqT&RZU{JyZ2SuB|kW-6}JZZw2*Xs8Euq=F#x4T*HW$Hr4V$Q@KnrW
zMnsGs&y~mKGHVfHL|I=PvY1LrTB4-L9y!8;eo~|Mr~@KMfTWO5^#lj3HN{P0xr*x4
z`pBr+CXNvX`xJ<?f)AXzMp&kz+OZrhb|^SCdJV_XLq)l^pxPK}#la91gWaquE{Bpa
zISikUkGa_tqrS~vjLS+OKnyxi<{K!3HBcEYN;22zSx@S)rdA)pYKr13Ok{sc*xyE!
z%K3&arh^3cFyI6RZ32hXZ$^V4+P-wO(mH=1E@}$I8oUMmbkwe~(qN;|-}DPun27T2
zJD;Ng&AXj(1IJOl!QN2-svM^G;E)fzOfLq5VyL107_bEaafS|6C##Q=oq;NT(!{aK
zU=O(k?`vY8h8#Jjdc-YiUk{N*unAPyk(K0EFzAWS=>TEY;+3@$TwCJL<R`o&Ym(!I
zxR}Vq7E~n}J;<GCunp#-B%bd%Z@zu_#4<9$9zAcY^LUsQOOa{Ep}Ewd(_SZ=F<@5#
zI*T(Mp2m@hF|5PnE)#M;-Bm*n(uN$=dzhJPa#?F@Y#LPBXGAfa3agIdXrqfz_Hsde
z)YKcqQ;CI0cCyR|JQ7}%df=#20uFgSm7aq`#!x+Sozm(gIV#PJUSnj<Cet3WWWC0s
z`v|PglI&A-q#Mzm$vlV{yKtd5!@wa@J6H$748XLYzTHF7i$T6ejbIItWfTW28FeX&
zgDor%69VVLfn6}@g{IQD?}g9qrmKxaJeT5m5}&e0m6$?!r$+31y(Tk3QR*kNNHl@P
zTcTdw31c*4R#Q2KThTH1;1j`_hE&QLBgL%=ECq^N(}L6=<(OJ?nye+CkYO{xfQN=F
zPB|jf5S*15un;w-Ernxr*h02LRFNQ1)#7Ugs>4XJn}JT4(sJ7O3ek4kbvht1VPZl|
zF;tk!(ub+OK?MsCpv`MFLu=8p1n8kA=reB<H!@<(0cDWLae4x5Dd=BYSvGJ~CPgMc
z9SgpsrVvEQ!AjU)`(`Va#xc+ohG;@zc+fm|-~)`p=3r282Wkz2Hd|wVOGTf0rrtp*
z#DKxa>k3CGFs@XVv_R*C6|@1BWrU&Dzs4fMXpFvxntcYVMsl_VgL07xv$zCXV!~2W
zeBv1aohhq?9ISguYPTAqw#!hPjVm^(#xzyu#8l#mNvrR5GQJ@2iAWQX1-JNQ6oLRP
z1946fGhC&d&F5;9+X`)QwLO^XwhqC-RF=#p-*0>0Gga@^+#GJUq>>u+LB)*1(Iz;a
zMT4D;#@M4QFyQM5WdRf2;;ots^%z-(l;I@n+>AkBz0UI_j){)!Vrr5FNV;@6?Uf&F
z^Q`EZS&O@d8EqJ}Yd1=G_=3Zx?Fc4!gbWp-f(<DdVF*EWB2+IJh}x|)V@+S<g<ytV
zSJ&8_YOd#gb47tz``2n_glGm$=X6SVbj>NeJo3liXK^}KZ>6yGQ19pv1#R}F=1}YG
zuV9W`D0kXn^KGih*MuC1;Q)yKQ8N0P3)+GJZKKx4;E<Ea<+E$(OkwcE8ajL@%53=H
z8WSls?0ye^U6>${nyq5M%y$fg(e_w4bJb1LqdBJNwv9c4kNVVKceIb<q68{ggo%Xc
zG*n28)k~ht0V?|S@FN3g(hZ?T0qFT5Wd0qO^Vb`6lA1cqI>H`Z$#=Cclv-o|yp6J@
zgW=?RUtL(Z8S1191Y4ZKL=#+X8{H3rKiqJ|&eR;ia*TpdF;tLu>xrecTRiD^4A-td
zkG^acoYF%`d4vO_h{Znwi}x<5LtZ;Ve_(yro0ptOF~g2gMqI*-60U=$JdJ9T!_7CC
zM@K2Jv_#O{)T7tT{8mA*q(yVjiIc@3_}eCqW{L@+zI}p%{(La1hX{4Mo#+w6vAuHi
zTWd`Z#+02&3Pr%9{2x8qgK!Z?UDt3(ttL=0NF_l)ho7lr*O;!=0W++1se4-fcDP_F
zj~YzH`5cVOz4d@jD>+RM_qNm=BHVF2sy-16;ZcYh>F^O|UJfZj#@}*D%)YoZTwq2-
zy?Sq<zD8)<j~)eaTne~>E(P5navo_xAGi<axP32{pVEj|?v{{%W@G7+^7=xM1bt~c
z-e&`9zRMVN!~RUSRfT9oz%{d)V$E3F>ASbsIpYeT&#zDy7=`c19FtU-7EYe(^Z!V?
z_HZWO|Nrc~u`vuYr(qa5hei&YIgC_DrBY2Hl{8Yxp`IOVDyJk#syP*<Qc*~KHglLm
zH9}6+gwmN(>FDeF{r-FYxv%TFp6h+TpZEQ`Ux$_vGA7{<t~mt8T=IaP1&l!;DJ7Q~
z0wL_S##cMIJIBU-Rs9oz3sGJ>+nRM=Y13a9hFAqru1tN8SKNQ4*0V@PpaIkqrOj$*
zsu7NI<)pRCW|vtpqQAcoj&%!(x;B5<h2?2$8qz=k{V|Z*4U-{NA<_e#P@=E;g0SQ!
zzEUoR72DvpZgRox*@t`}-(3&cEWwK8E<<8fQu$uj!o5SIkG&K%ZWq$^^C9SbxqCj~
z+k5k$O5OExeqXsm?BNR<N?;2;44bC0K3!0IyqyM|e?!I<H5X@o-GD>$XF}8<*HhmE
zx23xiGV4}g_u1WcfNxbEuhe>)>UN|TZ@YY~^Y(e`-&pKcGK6G_qin$vr*P|ZH)>2A
zdgP~W_7%vamz;@=+qJ`b-6~t#_2_LFmadp|w%|Z!A+C8*0+><KFaChUTs!-=fV7wo
zq~$*?^Bk?z>Pa4ZYzsn~*>;2C&NZWvFUgp3P4hcZhhEgFN-)?+KK9ZTL;*?x$x)k^
zjA<*c_iwI<<m3LUd9<Rh>18B7Fce}#wkmwZev_SY|28&X`nZn+OLNH$)GwRerF-`9
zlL8QV)bIY5?lEMX^&p6Ke>mBUZ;_o>TzuNWx}v&2sAM`np8&!n;+l-DkZ1SRx@P)R
zPQe{(?uSrSN`4zn-|r6$t<%egUmSkC^5Nt;CCvR^V5SK0xDFZBhOViLeZ3d?!P%F&
zb-*hk?a2|!-CrsX&2Up2SE}P7=sKY2)R`@BUCb6aDiIkF49IwP4jNmo!uX}CUkAyc
zs}F;<Z<J@?Z*fbWdEX4o4cO3U4cIZZ^)w!5FVS;mGxhMPDc5%E*U8EiP{J&vdDl&K
zhqhnV{F@o)hUzygENlqyg)lkbJPnEgkwxePow>Se=LAL11v3h4(Jz&VU+vBoHj&Fs
zkJg;+N*Qg}xAVzWyY2}W=ZJUOm88~I%e3##grGy?uW;D+?{0!L-cOq#t3BN__RV9Z
zCMP}M1r(i+QNN=`)D7>$UCM4VzL5SNQ|K>VYNJ{Rj2x*E_F{(fqWTnsFss6Nkij9R
z?lJAT!Ls?f_2tYgws{=&%^LH>jhei8D*ABy3fR$J6FR)d?DhML7<al3O##aUu~*a_
z$wv<8{L{?Xh}OqL))+$$?1h?v5Dku^Yzv?*AO_CL%7Ql?{`fd;{k~VA{87PWTo1nQ
z_>(*LpB#+qE4m*NI2+nQfL7lt>3ENmzgM{6Aw5EqK+e<3K=pNR=9)VDZuH>I6xih(
z)sFDog|XSoKI$3mxZ6G}?tdD*-w!glr)ewjE#yCVZ#{Awx=TZ>n*47=z8PeVa;7{4
zIHP9n-<q{Xq&BRaKl8#dd=sVzkCU*G7PcDU&zG5zRSSM#@1B#+jUrHNWbQ>reKGQc
zrCJ{+V_OrBuQ9jJbmqXB)qfVVaQf#UE0pi*a-X@E{y|Fq(6evSKCb*P1PB$U2v@%d
z#b#cxznrB3(XJ7NvVod?`+!iJ*8htZHP9%dTg1PwlRDOMWsDPW?{vxByK%SOfv)i?
z_tuo0!?_n--*T^Z6@2+%h#fP(O>2ppq;mbM1txbz@@=7SoKSPqS(Cs5rNhox->ee|
z`&aV$kENBKV?)RHVD`r$a2nPZnD-K&-$VqTH^Sbcle*(V(SLkI30p6tO=$7M4nBmI
zgMFq!&L{bg{F9lpLBzR<+V&+bE&Jq_N0Ka`s6Jba2Cvm<Z_<Q^!|%_~obBlq=iC(L
zqwcvHw0bbjZu3cv=Eal^W=>F9!Qkvsy%%^0N<+<{xpdyb0aLf+vmN(B=Uzl%Ig=yV
zR6vs<;bsNNrwIKe6ik`!rGQKSA1!)Qog1Y;yhjd>SQZ^e!Y$J&G43@teJFhuSsKYy
zq~ZReP49H;%KNx{4Yl2I`ZOV1c=IiVr7mJh`n#@fybZm461Gia*9A^d7d+P|`G|iJ
zI$058xc7TL{6hTZ`Pcee_Y5m_FSZ@2%8yA=*_Ds>5|d9v3^7pW(9Q}a8RtQ;tbJH6
zW<OB3X890?DmQi4e9VIEJ-<UmI(Igf5-8^5EVu#EIOJQVPOQPEJ(wZIPjepiDn`|4
zxx>PnMVMMJ{qmal=q^E?P4{n2k&n`?Q$N~CkD_+R?gU8OKhzbgjvVe`XGOH8B1Ia}
zfph1mP7zA&i;quL<?ry<zEXg8rNNw%@Ag%7<di#_2u?n(0JB0*9NC$rL4hnQ4RV!>
zh47e@Ph6AB=eT?{dws}R9}v=WK3Ef!U}HN7G3V;qPF3})+hw(qsF#i)*1qb<>_5NV
zDayi*iwer)EstaPm)Nu)7ZTT&O2quH7r#U=acooCuby&E5fdL?<(ff5AD&XRIH!~%
z0}w|(ytPbzf<ftBQ2FUs5{!4qE5A}+a`kGGFSmk}a^fv-8GGZ(PLsgyFndA%gORMo
zb1~(odo-S%nAw>hoUeC4!YC?c@$t>WGv`+?XH;Zj?GkKM<#ED7Mb2gkga3%+^ClaI
z?N)L(&M;7=UTSjR+FcZ$ZSBaONvjfbhx}ia!H4zob#|x(f;_vdsC{Q~LiQ(vH~&tN
zNmpe*tMD|6m4AtsX(JiE$>D6#Xp~=+_|1=_D6f<W(RQ1MO_M(VX3X&NHd1_Dm($ZX
zm%5@M@V=iyhQZOFug}LNG@kSco1jTFu07O1Onl{V;I)jan|Enx-p?0j#*AZB^>^2e
zbQl)L*>vVm=5k6uv;{aRC3rEUY9E_#`AN}^!4FpUi}^%YD0cH^d~S}UVo}|8_W7oV
z&VmP=XgIP-j?SvfNt)V!><y>$@xM91a@_vdpRYnoe+ic~k2aiOcPx)Mpq3IhA%JfJ
z?KW4F<0B@uJ?^8Cm5K+A&UNdvG1?IiqpZVgtZjNZXKYeTuc?Fss4nFy*d5=z9a$hu
zGo>|95rxye^;-Wwd9U}?dLkzMu}NQ+5Y`i#Lt=xX@zXez51H~=Lz-_}?XTJn@l00i
z)TLER5JDv;HJ)OSG{Sm7T+Z7?wl`QEEkhC|$ldHc1>zR7fyZVIuiInHcGUP=_kAVg
zh%5ArYJ6G#J`lLPJo8O;$6&;rTvas_f{jcAVxA~8`YC|9FG~C`w3K<rOF{@}Q2%#b
zfVR#K^8)j75NRg?wz7kk1y<9MPfuHCv?I(j%X^@|W<6$}e>u`$-G+9b<>HGaqBlxo
z$7VVg@9qaPQ$Srqgr}R%OzKj|@>usfYX5b8HAdsx9ji3tF<xd+L-3JX%QGl;__cl`
zV*sXP=eV2HpPzg?p2)d<5^ZB?BaukYmgnbyZ=aCfh(!eyP;fc|mLH(qg@57iadpGs
z)s3F3(yas4Qxvjm+qMd|)WoWX(;KdBw-wz?t;41kPU@LS7>?b)u!aIQ>|;fzju{6U
zopMk=nFXW{zgZtxS5|O41?yRSO94+dVQlk!zqlgW*X(fmPWmTmz)9sq?)Da?U2K;B
z#{2F?RPeR&>e0-N=QOz3ltS_xqr>)oe!#cv{L}Mw9U8Vf?jk-!xkUcm<EoNqeZRQu
zX5`0ruD|LCTC5%Vl5a2FTT+E6f&dz*Xy5R5B6kP))zpB-FuDD6aIX@m5O?D@{s6dk
zmvxN#IfFLM);X2C*|1Ix+l`|Bm1^@!-LdwLj0Ytny~*snT}=sl?u~6ojpy6xDFIym
zgjz~?1<Ziz?>58L_j3aNlMDvwx-JC}Ayu2MECGif28mX_JFmq|%aBf|kH1OM)*n>Z
zKT()9oIdyM+OfY|Xfb{3_olRI^;b>8j20D{{s#vQ$0UxP7rCHGsp-wLnE@xA|C}Tx
zFQHW_x||0kI9ld9LQGY+`}mv+Z9Y#gv=Q8)Nj{$19Vh-U0_qj@ImZ)Z=I?2~9D`eI
zdC7Whvws0-ck=ND_(qk>+GQCvfq4&Ex<<1h$J^K37wr$;cuy~<)!yc#+J0ZzwIR-G
z)f2b2?q<#ElI{w*&g>3P4_MQ-45R^B5fB?f)YE4{9mCHTtH+Cnem?)?8WzYksBNw#
zTn?Z?bJp+KI5zs<ogRIaK2*YwsIhdAsX`%V?mK*bZ0sms%b&w@;QYp(>w@0v<M0-2
zxMPV5hO$?JN>~@)`TdhjBU!R<(Q1ILeiY3g3)v`G!D`jIjc+HvaA?vhX1of_g8p|l
zAMQRc#S;GpKyS|?L*+i2`#I6&|4wmr;uxA4XxWwRC%H;rm`(eP)OYj%H0ehf&OM+9
zCeJ``rI)J5gO&^@kZVTRf%o%nGfHq6#EVU|@b&_|7m5Zu{i&rxG5=oEKH-;$DX0le
z*7SQ8X+RXfb`5_wOnPCY6&*DeSGP)g>iVoYMS`J-2J~}7zGL(0D&w&-*dE14Bj-X>
zz3Tf<x0|T4GRu&2e?*w?&qaqtbk($DV<;VRrf0b6tkuR}808Z9S^>e0xxy4$7XYia
zGW@iw!rLK)zdUQPRqN?^i%#@^#i}-pvDdG^8}S_e)EYfh-y_cXI--cNFey{NnBr&g
zxbEljB?ry9PfYbjomuV=6V)Tk=Zcd?iO#-d(6<<fBu@e3J!8M$6~{>Qugkx@eiEmz
z0G^dpX=FiZAm0w3xz-(J9_4=P{oSNxa4R$p=KyJZ@9IkA{a~sajk@Q(=LgRUd{Url
zq0L6Lhx+tFz63Cx;TQD4T^(TixA2eSxx^2!mPtT=9HyhFSCNCnmgb{@G&Q--60nAi
z;~tu9@mQ+M$`;lLj6`lFRl)*`TQ+jwG%>fP`L5l3t9`od{nnF?6s8{u;^Zr9SrFYP
z$`*TR%ocg}0+G2x25uh#x<?#KdQL9S2CF0|Q9!f%d@d!wsD)J|kgMK*CtE?Fu3m*U
zps73yDZ;8iFm=qA$Gw*?sF?C#eh2dKbYE5lx~5CDf}?%h0qthcw!BT|k`8=!$X?-L
z^);XA<WaUZv=BvSZXWP!VP$^@+FdD24^o0=E`{y)HHE3CC2PS;YWw{@i*uJxfiW0=
zT8n?Y75dRI!17?8>j4^l{GABxya@m8@FtCvb{}8gb1U->_%i)YkUXOSzXH%T+^vnO
zVlX3fq(DOcXnXgnx)R#c4BFO3KfGM+=ly}{2+!GD01ceU*-@waJq27!=0jYS3--+X
zx45O*nIgNr46QcfmoD&jt!J{vfm0Op!8X++zN#4>Ct4&YU+fNynqtOdaz4)Z`*_II
z*eZVTbG>BdSBWaiLuHTi$^C7Oi61l_1l`pw*6Oo>^{t?5E$FK)S=U;+V*(3L%E_8v
zgF3{Tw>|3SsjECkE9#xIHr)qQssWhlD$U<P){s?s&FIE>+e;?5?l_|j$ig^z!NC+E
zN$K;WvF8q2f)xWQ!>j%a?@?_8A9!S8sTB{glFP&0K)Qc}&8q*}g5=@qcf(g*x)po_
z>}{*<c{~uTxd3z&0>)E4x9WpVhzq&~%r03~487|a_sDu=(6jjLcJI*bRYUPAH(G+)
z;Hx^&kL|gu?vI;2n_u1hCul7EN@KeE&4I@cozKP5tW(I#IZ1hFg)VgxlMIUgn4zbF
zAD;l$Oir!3Umpw^?`>Zw=!#$ay0k|bovi|{TD=VY7#s5MPq(VP5=(w`Qch861o{iR
zQJEn>#6jPug0Hs)-xz<4ZC}+sT=6S1uO1#Mw|V>|8tb`P=W+bw`;|{#q_>z*udOmW
zC)Rv4AM)q~y>FV(r+?v*>R|6fO2`vR-(8!>FHKgX{syW0l}&quE!3~p-WodU+;6ga
zwKlGwV%Yx@-m~m)h|2mkxYhkX3_{eNuX$e^YOnEhd6gy{5H8--M1`_=swwJX+OnHY
z7wl+fzEvvp5bKuPu7Uc6{pjr<O;$0tUH8|c&%rO;=0Oj<s$VZh5s*2+7k39%4Fpwn
zv)aQaFp#y>=AdENNbf+1_F$;_V3^B#((_!#0%8-IVO)LVM?R<%?HO7v2&VD`9)ppC
zgIhh<ulhC^G(8yE4$-R1-HsXB={FR;enZTIEW89_0OS(V^XjvJ33M)+-4!!9v~POo
z<<G(GABRHPfiCBMj?1$He$SHq)H~)G7JlluI#A8QAz=Np)P`r<{%#0*uo3<DX~wr_
z#}LC|wgVrgx<Qv=erCA(0xH9ASa@()lsTMrX83s3@ZyPv;gjvd*@MG5)5E#nhVu|3
z`Pw6=%ts1bMo#;U6s{jR6EjkDaO7;}Nb#AGb5$cH4I}5<M@k1rE=-SH{5En4F)G#`
zEi)f2cNwkl8?9VFS`{;T`QYf4%+cyIqcv5dR~tsJwU5>gj$WT0z42}ICSt5kd+e6^
z*lm}wJAPyJ>&F^m#_k>*yO%lEcxJ4rYOJ|o?0)-L%i!39>9L33#{NT$OSH$O=Hsm{
z<1)YTw)NxfG2<Nv$2&8}<!8pbsv`3<mmreyE4AZ~rpIrt24D)_HWqS8LG<Y3_*1{<
zHC3R?Z06oZQHBEL-1u~$>iOvUQG6qJ?=b3^LX@r$Ejkx({U!%6VgM5Xd@l##=-N&`
zh+u&mC|RocfEoux&<T?ngW=BG4!QO6*ug4w#UC@Do;eL@I%mE5xNU6x%Wr48@gVPL
z7HUheFm2(va_cj78k9ta(m^O(4Dn|1;mTHZ`qCzc(z9S%ba3twpo50$flzNU6i$QE
z70|it7cer^UCFm%0l)vEG-e^j8~{#*(j)i;bS;6-BS&njy3aLZL%uHo#7LPzBZ5T(
zH`R%L`7QavA!9hmBoG-KB1~))u4Z!;%K<Mma*qQlfhDA~tp*?hvQU`F5-vH+9{`0+
zMH8OJ4U0o2kVU&^5R26O2XG}U1}zMXSaMiJZddZ)V(1>0(1y63$3n)<@(HZ%`Z`k#
z<V95)0A~Y{Gf_&vGw!pfqe@YRQj|J_N>`%Ns8E_8;5~zUv0jumD@x(OF^vE^D>EQB
zI-^b$^g@&v0q|0QZF1DHI#J4u=xDLftoS*MlbKP6ItWgsDNz|fCXC8IszB|Gc%cpm
zo)5w_$Ww7eua!ptzwZ;@l;DaPQ7R{M+sxKo)Xepdd1}>$Ni(Q@5eP<|U@vW#GyCki
zSy3Vp5z{!evk{R|jnX1#IVeyWpl~$^kE%u;BW4na+u`UpFCHMn7X(}INPiY+8Yf)L
za6o<E+_YD+^d4N#i?4IP&$L&+_Crpz%U>T2K|z#2hD2oU02~}f(H*$(km#dX0u%^B
z8{u2-X2L)q<q#5}^HVwiL%Aqb&Kn9srZ=K2>EPv|tqHTxlm2mOO3_|1bg39%EYKk3
zyvOkCmEbyK@%Hs0jd`x`@7QJKKaBlG-F<)#7>4Y|=7WjDqE&HRm>79xjd05hB9ewY
zI4jzw+<nOcTsezMAcK~5qSO>V7SBzPqY{d__ZVPQqbMz(KYd}(Q4j%@i?QH3ObGOl
zT(p}7XaJe%64WdD`yto84YASjx%{J?z2zOEpbyB58NvM_<YGo6>gC5b=`#~si1Eib
z!q!is1P9Qv8kGhJRPm7hLr596X<e2mqmIAQZzio8wMN4JoC8^}6s54a>JF%MG4fmT
z$8SZieRXz!SAruJqI(<mjSua6@miFK7jBVc{_Duxrr;lT{nYC9VLIW{o7_+79ATGQ
zQ)m|ID4N3?PB;V#KHH(uWa#>T0?V1LbTIZia*lE6bHkdvh0FVXJ=}+pe|+BY{;C}m
z7Wb}p=-siIw~+t%Q?8sh!UXw4Br*VqszasA<1zM`X=09Q-Zs->WCmHpmWxuzt@yJ^
z-`hbH9o#ZA;YbHj=&2J9bE7x*Yd;gMWkcW&!o?n>03LE1703N!8`J6<pCF%m^AFf1
zL8TEH<~@6p^0%6<_@Z(XE&s~TNcocPAXLBf#rMiqOES!kB{aGSx1;m*l{0r1k_h+q
zJDmk>W`svU;YyHaQ_Wk&5;~s+Xq}0#hvtsS`OiLPI_C2N>teRaxmQX#^qXkxEH_my
zTB;Xn$UHk>tBUx|QDW@Uo;o@!Vx~kD48<O#gZeYiwTky1U4RqiOMMP;h!}e?M3g>*
zN^6AsT72-xdIODvrZuAIDf&pUFl{(C;Th`CFi+Qi#<KHUX9brX@-`6+j6yARRe@0s
zsDmsK&we3A&X4sznRpGgCjwm5r!A;2=^)vnK+bt}2awf>JX9@8Wup#;AZ?de>7XEu
zD1@^4sl`GVjh8SZq!nL<agYbHM5!UD1SRzA-|AHkqP=9e&>L+#EJ`CHMpYInMdR?S
zxy$zK!`e7F3w##8hsRF+`WNh}f_RbP)O-*QK2^^LYIbSfega;0eGaFAu6TheRr%89
z2z*H{72T_+M5G^$sd|>?xA-FHa9+os3+imHz7o1r%yE*z2OIyi-@K~Y$X&}8y~q(+
zv;TD8`_o~`+c~@MP#pZ}gFjDDf4|8=T{+*H)2j&hJ0SAzT=#eAa7J;=-)GMT_Qmwt
z<tc_2NAdZ+i`i$kJ$X48_Wf`0-xsKSU`&03Qhj6s_pius8#=@Z?Qk^g5lB$*x5e>8
z4FA1aF@`PXt`Q%s?FOb1X?zfv&N+%c_`%shxJLOi@?g9xO}M%)E;I%paRl3F!UzTL
z`xWbHRMs&lO4CM8X7I2GUA5l)SC4N6Vu@k3aks>9jP8nmJ!CGlGhf%6E*%UM$P2AE
z-i{yn(y9^F9c%G*;!Er*6|Yx=uu8mT2-4l)r~B)mlm6nMvrhZoIZq>upMJ7}b%p!r
z9GJS{^79;b<GsCJb{_3VCOT{~#x)BwQeCgR!uM^lm_6|Eg=fZGP}f0g$cZZV_!Uk>
zf3;DK#cR3;zmEodl#KICNvnVT?C+%bXql-J7+u>ubc)<g+db0Y>1JI0JZSb+>iigM
z@BVS;F6g0lxS)Pw@OO><CuOT>qw}0_`^;s$e7@)KlM%Ms)7goYt=yD$Rd>#u*;z9D
z&?(&{<+~MXDJfh%BjWqRpG$6Si6(paadsQm>qXl?WItOwh^<)f%fPqJAHYRd#yBuN
z=d$NEuTrlo+kpS=SJZ0xcjhY(e0u~Pj$A?W>7xD~uILaMgmQd6e$4V1sqf8YPdo<<
zcJ}DbS2ddD#Ui9?UL91CzxTqF))O2wa98C)*j51IgGbM3AVPQ)2Gm_AS<1jBr<^*p
zcrW=LP_)fys_$q>$q2p(;~*w7jQ<{h_yk_S#6S<_c0NBsAj2&gddl5V3_XJ>i!#%n
zO>NHq&^w{H<)wA`mo|m9#T2d!VoNOkg*=7AlENrbhaXciL^eE>Q(XwtATDKTg_l%c
zJ9jY<f>3$%&KhnzbNUI95M3FDB#;$C@3(LbYcX{F=({4#Xm%X*k$YN^*->$_)x{y}
zgWUSX>Yvlz*EVm?uY>Z=$K5)(%^I?4z-L)M#*!XoN`j4&Y&XU9TjLAox8}bO(yIe8
zNw%QKj&<KI+(vrF_2k>w84D%c<=+C-3Oja{G<|;#S^M@9wkvQ~!^p($EA5L%E{m?k
zwD$+umY+TJ)4WZkA+VZRJhSczJIMA~sn-t!=62-M>8DdDltj{LRWW`F0`=ZnC({Y2
zbqvx*rz9>BRMi9kPEdPW4#OP3!Y`gAh=t3z>EfzXXHKFoRCWB83fanGR*J%Sfc};@
zoRb8Qia?2<7P^hoMcqV~*g-9)Lc6V^Z2&1M?aNafBp~@V<^>`n#Lf6>a1s=H+>X;~
za<w)|jziOlnlM(lW8jLv@B{EktBBYST4$@j2qEhDfq6A<?Uye7-7AkUb=Ho*%5#m6
zpFj|_b=x2-f1?k;%1{Q5$Cq6hm|F|I`5;vZgk&dSG#IK&HpYt~;Z8wD5jrJM!etHw
z&MG6ErCvZ+;*ri%X2z#xp}G$puII~RRn}MgdJjlZwkb=iWX1%$P!)I9TCy>lj&IC|
zX!w>B);j=VU$Ma40HWe6W+Bz^Fz@OegmrWfo^XYL1nfEcX?|pSgE_o(zxELtz1=P(
z(>_bGRFgh>JocF;bF%7rDnbt{apF#as%~@uX^_~$t*VR&kUTrryW)7*EO!r_E5Wtk
z`EWrQ;Zz;t_p4;UtC6RMW^*;|X6;XgNHC-FPUjDn`F3Ft$m)eQ^RSQxI)tMVzO$9;
zkSIXl;SeuQn>CaRG^`H8tZ!_i{pvfpXeubfv|c;&Z%rQ(rnqjlLg|BtqtNT8q7p26
z`*q!=4N$5DOm`NliO=V+PKK(e7Z*Gg>$t%=31rO(kYJa1!ezFA=38IogGC}p@T3A=
zbemP=1lm{}Kt@+{M@S~z)vf|WILNzI&p8peAiiMe20iF*(smyE(dfBim5O_Ly@iQ{
z_?#{Bd{>s6z}~Uh=oWlsM_F!a98>Rgwa6_Y$`Xd<>wjoOt!!o-C)gyJM2!Y`h|AQ{
z>X`b6@H?QKsN85YpY$Ov->HRzr)N)AdVCZ*CH%}&U*H;y<Na5>(ojDrF-7T=OHjdy
zp=rZR!^d$jm`7)BROzDg<-*42C^TJlAKTeziiW^_sMJql6P!oEOp2{3*P6~Zv~@3V
z8<ygN=a+J?K&0Ed&<%TP8IBlEM}*5Ljv0)Hh_eFRUzO$EzREXzru4bv<Zv?WgBi90
zW9{~evEfjN3?F}F35kfxzME8`Q4z>>+OcIr!b}wJG{tvCwNy2()Y<46-WQrHQ9D>&
z!F_6LOYxPRYK}i+__*m4ZIrF2Lo>Tgn)WxeKy$5&3rWwEf$jx~aL>PTgUK18YXrT9
z05`kyj)l}sJ)(tiX6VHp><Ar!<T!^1n>{9q;s+CRYDNx_=86S}>?ORY;hj4D?#~I;
z69dU~Gsz;?X}3e}+>6vYneK6JxBkadH+}w25;tXB-G5LUzMVQOvAHZX{xHwAkKB2s
zUORDPm&;WfWv1@VO3<jj4;PmVbAGLCQ?<E<N}xW|d-R~g#M#FsW<27S5YK(w=zu%a
zGS8}-Mw(A)HW~z*-9Eh<R;tM+?!-=#0&+x-)e<*YZJGQVy~e5e*(ri=tHCH9DVU7P
zUCWWLw*plCU9M(31yeWy#X`5}^SQglQQ1|S#!IFpI`H^b14V?4z0^QY4#6%zS0bLP
zkg;c5lMM>l+#Pt}ctY^bCbJxr%Y4W!tb%U1z!7$Goa$4llST_O?TCVo%J&AK!N2Oo
zPM3~bc}IuMG?94SWq-=l&8A_-wC5ssR+rbVVVSY!U6l8S&;WC-smlwB9+!n%dCA16
zs6{&H^u=UT(r-&6Fam&jm3^ukuV6i9<)dxNNa=Bf#?G%=*-rW3mheBG;|qgUo6o`=
zCnk;NX7jv;rQAzIGI4HJbYN1do*oZ{E%|Ga>iZ1rIxCC^sx8e<DX<5sW#Nu4C>N+y
z2k9_Dnp8XK^}R30Ec^P4$1W)EUmAHU<p@Yoqy0+%y}1ebJ4wJ+G<2X$eb<b{2O}07
z`;eHkS6N|v55y*H`Im${#eA_y1DF50k$c)K04KSX*D!f2FCExze3uStEY>^bCOUH}
zR)5t04^;rJ9N+lqN5pShy$K`D$IMu7s>5qRn(G*Bh=W{eVVysXRYrp7r`J21mp#X$
z4JM6VKJ@?Gos)c)4yr;HZ+JQ<XG77x(3OqC_nq8~lvUD;qsmT~tKw5|nvdbX#y`@h
z3LN(U?E5dV@X(?LR4tBazd%=8`A3RVZzbj;9O(@|`8%4nc`QgFy{olo%ma;)eGgtX
z9c+VTZSjudyMN$&&GOTasQT6FdJixuzzKLT&olbD=j_txJ2dRet6^RAayImy_3_~V
z&hr=C#t})qL<E(4*2Qr8Am1&RZ(QdGrE^^)pSwhFU4iFH%@-xk23?-X?0@HE`V<KS
zfDXUq7j6<SFP7BTNvN~3=H21m#aTKvov=ccCKKbFHof1`kPjJa{(j`UegIY}x*%i_
zxuFf#!u`p3HgWv88|%5Z2cR3m7gEk1t8J&-fKCJFcTb%61bps}Xj#=qdIn!S{FZM8
z$K9FRy26+6n=GK_zG?|?Qw%d5l)P=xW4>DhpuMf;wNf1p!yp>#OoqVe5~~H7OSIG~
z%g_Sf>NT*W6*@z1)VC9Jp&6H4i--Le#$3b<;sW=+9t`^j-a75)SqmlALX2rpT^0aq
zgV?u7iQy3aaUbsinLa2$2lGy4!;HmC$o!%qwGP-s244K+FK>b93LqxKJ`{>1B`Yu|
zdD3!f>3d7}awMdMPRAB50ly((PI@)b$GZ|njb`Z7N=@**n)Piefl?ibrZ*Z!$Y<y%
zz~vw5wpq{3;~3gNE86Eg-2t%oZ6!rBh~tbE3o=JIqy;V|vLJTsC;9>@F<M$_12^|D
zArZ$X7_bF5A8o}BN;M=yIpj%~5o@{2KES+Mq<?2155KjNI1rO!ScncIj4Yu<ny#<r
zk`z*t`L!w>=|<NOO1_jRW;m`HEXyvZUe>;IfuR%Wvvias<}--k4&;JV>lKg0k(w00
zbihlm4sUyiU~0!LGVIY}Gx#Hnn7ahBdJXeuS8FaCV0shz-%Gh>N}ds1=j(2W%hVS8
zXow*d_MObFZ;?>*w^(u*+6wLz1GdTnTo$>5RG)X_V5dw&?zq5ri-@5$j5$#A{v-k~
z8`v9eaE*O^GzJJviD0p*n?!i-(8ARLpetr8G@}KY&afscrcMi_c4?>reO208r!;tB
zkCk5V7$dJ<{jBF&Xf%S(o4UoM%ucy1$ecOSSTfxVczHk(V_*O^X3<rGTW>Z(^}?5!
zp3hy#j2l^ic09x)ALhN_6SM)c>Z0F~Hko-eLmS?TwwCP+)^wio^GJr0mWZXkJc94y
z+2w3?6Bd_H>eDyw<5MTGtUd4A0wHCwy`#_ikm*(fd~XUf-VSO9_%uw><8I3+(Ncm9
zuO>V*s1{A7$!tRytjz*JG1I&F?L;5XD;svnPGUL_TWR2@Q_UdLc$uu%UX%&~NBSdC
zrW;A64$HiVIlEs-O$WFaY_c4wk-iK);{|DT(N*IGF0t*Bm6OPGmZw!aW+k96`_&IY
z1JFtUVZij}$PA;q?A)0^E!R642E{`<n}$#!%sqP;sx2VA&8KhBB0zviLL=c0fQypp
zF%P(I*y7y={cRv%CJW-=bVxc~MInuAhi0@?oT`SRC;&8j5#~*moz$Z{&BNSgrI5&L
z@NrO`_O#nXWJU&H67bZxkFPnsVd<w(3aHX0=G9E^Y+j^+#IA&I41f@NXnm#tZUB(b
zTdfEHEI79@pX(-%QmLe?&d^&&VAOw1H3A4wB&uw{*#J$Vs-GoD%u~8Cje%AwZP0wC
z*AkBme*)sH;zDHrM8GJa=XV{9T-&ezoNpbzz2P}in+$)|z&64nBZpw#!OV}zU8>1#
z4JC9~rnKSmAf*aYGjzS?vJ^+tT4I^jl`z%t*9R#VJ?Y%@27q%tTfZ?-FOum^UxL#l
zkUECP6yFID$wLA2%GWNM0?1Mj)Vsu|=U&ris^D;?Mdlvq67*~lVQG?&A$SbX6m-=A
zx~c)}V0f0aZkk#T!dn361*U@lxBx&`&hnQF=&Gd>ExOFBSjHC6k+aXez)I?6NvGG&
z>_^2jdi<JNDU`CrCT8}!_*@*g^6$FT@CGC}2!ktTdd2Z+77|UuP40;RY$@+U;+3nk
zIPXFph5|s8yaqp??d<B2Z8E)@k0}OG9tMm%Np$;&tGeXX@*9v9vodP2O}7(3l0SDT
zrK{FU)SdaQr@$G6m3KV!f&sj_<icY;7^)t?2p9?5n1l87GcRNo4icCLIE7)V=leZ9
zx`xDgdVXpVoUs6m-Gvx|g9eSijRS^jB1yzoG_>j48{CUu-a;0v+-9wyzC6Gm3J@d^
z3ccQC!c)Ldm4NVCpFYo0&-Ht}X)-J^zNprgQ7W;h-{Sk=#)f=8S^c&<T?XIYX7vh+
zqB47JCADF6H3`p&4s!`%B1&K;oToQ6C5AKGAr6pD&!vbg$<)ID^L4NlO1?LIqW(6{
zyIK~T4q6ifC8O&aCYS~hH+&-LD)?5)TA526%uD>rxAB^n2PB0I4l-m~tR9%nZhPA4
zRBC@|Z6uPhA6ZZLP|6%^;#W8;TuPl*44k*7BO_h&U9o&CF}KTZ;Lro<kETW5a9v)r
zQJ2+rm|HcHdIN12oMbLiUlBYp%;8;`0q>;)<SE%w2lg?PI1(N?qhVA60|F0if<tOK
zvfgjouK(oGJtSs{vXdr&E%4G*t{<5zwlCewbZ)~s<4Nc~gh!D(_V(&)%zZe2XdCyS
z5u-d3Skdx1!oa|8fa&F70JFK_Jr9khO9&r6IQM?_t^_RN5_&oG^aNgFS9VhI4f~Wp
z;<FC(cr{(;e9vH}x!FrZ(Hn2)k6w{XqJe}`4f9Usx$T5nlsBaH9rTdv&wttKK}=qC
z4W8N^!JvS*bD7$TfVSg97Qm^WJ~EfYy4EJ%*%`0_0Sgi=f)GjE->`g6_r>tDs*6RW
z-v+#kUUxlXs=bJ?RcjC6i-U3+bzRc$c=w8C`lN^}1`G;d9K6kA=9^2g?B*Zp?_RNI
zG{o|?!Z!G#JNn+SWEmv-t7S1uO}-tP&G(|hG@|v9!Esis0|6nxCL4(faF27-#)~Z>
zZ1;uMb6wF&3UM3D1JwC!wI%tMSNbh{(B;iUm`yzcGMsn#T$1?#{+uB+Xya9{-qyW`
zeHrz1%Y`}bIIgD>A>5hb6#~0r;&kl`)Z||fCHj58gasusAN=I^<cQs!c@|&IEPpUp
z5G7iyBFYJ{#-Jqkzj05r|1#K)?dhOd-3D9Z#Zo6F)4i7aBUp3pJHL6Z%|V~(C^Pel
z(}f1}y&AXrdoVikTVV-Zhl)|r(RY3u@sFASiMtAO?-YA-c#$*kuAi``-7vdoDc4D$
z+4<GOl5RxkDp`R(&waIA|I&$`A+KziA<+nmcXmO4mxV~oa%31v_janxYXO!NBC{kg
zWbAov>6Xus;|}T0iA-i@-4pW#6lCl)dK9+*QrD_C%-|ne)IGw4dlzUnyft6z-4>h~
z=$qqivJiWT#RAHt@%YDYFuT(8a0Bj*ZF~q?WBrzf6}!3j=A>U7{ocm*+R*)>HqhyP
zt*_IikN^JcX_tjqN-Sm!3<1z_b`iFsdQ^IlmsWg#hv&`14{vUK?i;oD=8up3qC0EN
zW_D9Kr+-?@nru;<`dVY|jRneIwtSK8615>Haj@l7O0lgjRUOs2%aXt`vq|^-_TuL7
zeNVy8gwL+26o9<&v*f>0cblm92bntAeUN#d2mhsWUUJS1@pI|)zi!OK>KoFHTECdn
z%^LsY-r>8k9N)$=UTtL>3|m}$DAjp$c=POGmrFhmnouhie25WQo|UhA{v#OM(Dqil
zs!1hRhM2yO=w`mW@h5-BJ0ZB@UEKxxS(oVV8HT6X04#*J*GOhg^D%H{sx~*;wWe4e
zfaQ!WQ1d*UX+C5;Z(56IR=W6WdGl>|c$3OI<|(sCuVfg>#toLj=t$<92lI@Rq1#wL
zy&K<q)=f#Hnu^~0Ry4ML*^N4k-y2X*KX=K^t;NMW{NMBnC?U>Q`GHOuZVg{xdKob9
zZt=bNmGAN6yJ2mG<E(Ug`@g*`33YtC1DiLo)6I?Yi=Nhvjp#vDa(!UDMD@0}En)Ts
zW#08}$|LT)-s7JqV085FAD^YPjHkTFg|lp}l}AtEvAzy(x3#R%K*bsqM+v>sqrKvK
z*}S!s)0S($1kxNB2FG4!QG1E6cunbwBx>Z6&%d`1hA3_tQa{T*w!|=aAMg?EIA-NA
zeFtU6^jBHc{BvcYWU=O{IzdekgTK9ZBpZJ><m-xSyLo;;hxcs;q&*MQx&V#-Yd=Cx
zaCO&kz8>!GbUxPd&&pR)W4v;E`gcwDN>Qr>Z*XJ!{A=drO;7af4Muk5Wv_!j`yP7Q
zG|Gf>@Q;rPD6Tx`9kbdb|JJTN9X{552^=+lwH*zgTrgA(`*~*_di}!S$+mIp%8QXk
ze|FaS&-xwD`7pRFQ^WaG`a-GS(ES<z^+m~zb1VIhmR&mfO~}YKp!#;e6<?Z!Dnrih
z;Mt=CxBR>x&g7H%I$nL2M(4;1f8$*{%9ZGSf6fW6-57sodGXJHs(}BmMC&cW*|ce=
z=y90A48*nfEed}_ZBdeWDKWtS&C?;3AxLR|nr3Ck-u2a<qMIJ5M5|Gt(?*9Z%AV9<
z;~J5d68>}pTze^YIfVGA`?_&jik>Pi<4Y*&QhKgZ>73D9vvhq5l^~@4(JR}HccB|A
zE+t@7%8k;1COZ63LIJ>qlRYH>M!x40)G%Q}WZ2^~Grih)oJl{I-pt@bp1K}?tPR0a
z#psMrj<3TtETnIYNLPK>C44al57`yJ^3^~aQ9K`J*m-=0u>=N0nIz0N`HNuW)c^#h
ziGI6mubzB|R@{Q4CE~}9=(o6i3yD=$i?0-&Mv=&BS8m;jRT6Q+A+Zh+vtaTj7vbc?
z);e}$(TYbu<x`Bjft5d+fuUdjwaf{Fuk+`rQqiWxM{n$Y2Q?j*28b)1_<=k;c4pcr
z{cb^)>B-vOtcvt6O%-8_t-WrLcbk1UD(_BA($A;MN6K!)1e-?G#ey#Z#aTopujJ_E
zO)Jc*D^trR5b&?lNT@v<h*P;(hd3KC3b^~%5A0YbfMdC<>@bb;Hy5MO`5VKMaGcmn
zdj*cWE(H$xDGM@eG{u|Yt)}m9_g?O*iM->Z{}F#hGo<)}b%#5kllEl<4#C9T!L4|n
z@-+vkxbV}GkEgIKo2D(ityR+%9w}s%+V>({yG7^~<G%mySYDhfZ6>4BW_Jrm_n0pt
z+#w57OrSmU3+G1>M5lTPxTXu8Eg39z2X$5(9@h=)&{$AP(U$XlK3MzNFQj9_w<arh
zSgoe#XS~x;ZD%|IRxI0yB+gQu+OwcL$s+Fs{3#e#W;_`&y1n)cU>(`I|6AM>I?*Ku
z<zXFm+Ef)<>04FYRf|mEArtq!(OX`If$B+m&&TOpfkpC-$5VI^6^G2S>YW-Hzt)NW
zNOOD)twW7j{$B66NC!P7dUt;03A-~^X<#cb^d8xF2!A#7%$^9y&TK!Vf?znp+^{G<
zbDi@|ee2u_7o-Cc@at?;<(Q}vXhXS$gV0#FlMw5k&J7QvL4(Q(v`X0`K&TD@HyE-B
zIlH5=TAUln+|O>+O&vHj;IdWa1Z@ARfcjVt2+c3k|NCpB1X+~J#41-!{Q`Bql;y3F
zD6BN;GSy}pphlG$E7%Z()7@LS=E!JMeKa!sa^4CXB|s?lSARBJc09aoWz4xvUc9L5
zeeE2RM7)M2de%HM(x13LOxEH+#~qE6g){V2JTV-AUfW9~&h=N2O|;SJT`LwHB+mFZ
zB6~wRe0v=9$(K6yqvJB&0BhZ`p(OBLyRDt77|_JKtC<Q462n>i?MuSwL*W#9G;xE)
z7EBH{-x(4~<p&#G(R-Y~&aBMs$-X@`hMR|X8gD5pTE6(JT?Eg+;d<|9K*FJ?=dlui
zK3DB?%|A46q~^LCfzzs}jxvAojiP6hU+5?vc5>qdcx-4bSUxY!wF2J)K`j2zpQV8#
zQXLwpoN!^&!{Ff%9O>s;5Gio;DK>LsN0q`KN)Re7YkdeM+k>(1?xoBgPc)u|5~vc;
zNqmxIi~pdbP&iyH&~o4%N1)IOLCwL6fU*f5MU@RMDJ+b_I8Pia%Y{}O=1x#c!_Ih|
zhM2bO)<Q;pT-U|1*hW_x8&|^~C1pWEAM7TcDu%nv-%>v~8wkBhD;J|<sJ>Pd)y)_D
zt;nI6FxpO1wAfC^u^}(LZKu}h89%QD#v-P$J2CsR6VB}2+`T}$DRF_bQQwb_p}pR-
z@hSOI972ZMm~vKEu>gnK<-?+_P9pfh!Faj!Rs?;A=7kWXOR4|}3YpX@%xbf#zoovf
zQSEd|_*qtP-B>zxr&g{+uuMFGedPeqf6TN~?4rstvSn%kK6Lt5M$VdKQ_aL)x{ANH
z`mQqwNGHqR(!vq5y(O0Tu&daC_WD+At_^H8=d-1$Ms~`=q>fE~mupmPQO#|$8+T^f
zEGw1cuRQ?V4+Uz4f8X&{3uLqK#!j!x+}NlAneh!4V_0xIkMFxf>*<Whtx-~fZ6RwG
z54Tl+>ceb29TkbMhOPX=z^z|Q*+^8xwVl$GppHu35p}k1+3eJue=pe?W{MV6pOH?l
zs)mvj3*z^764{aqe#56G5EGkdyfczFaId(-QF!L*Bb&NICPlkEBOOnK(cVM-*qvc(
zG>&gmZYJ7`fpx2&L8>p`pzTwLyu^toYG3a(?w)wJ%Si$ao;5S_YJB0{(QUEa_Z8vo
zY=Bdi!~kBWePmlG%xfw9niW}2n9qpYHo4sRR2KWy0t?x+LgVCasto>5WBZP@5~xat
z8Bz6xul?n|lkgDNqiY}3`WVe358&gUokk;_JqA9knV&T3l(^X*di?242NjM`mbqR0
zfKB@_!&3#?T>Kdc>m&J#Yi#5!?eX)U1JijAkwrUIPQ72Plk8*sjodnXfiE;g?2N!>
zt@U2$V{I?*F<zKK5h`G(;0qWMZ0VRb5DHLfG<=ACJMEA3VETg0cxs_F!?uCHjquhe
z@<%|oA;Do+>F8%YMz_Ov$j^PxCi}aTC(t%h^`mWb&TzArC>2f?;rFD`PqCK;y_7$4
zjk(DoE5N(3j~BVxNB^%f_2XY@u8|?AU3>4$&%rsZq&1(p_kfq7sSemRUpE-n9E;j9
z1KzT}X*|ogHq59=|BT6w`WBXF*a6Z@l&d)tubf+f0p9!C{Z?{tnUj#$%y>NXiTG!d
z@IBsm!+xvFlI}$Z$OiwYOyny#soXehe@X<s!KNL>;j+T)jo(Q;H31!3&gws0<I5A6
zMxXkS$$sBQ#%&d#!x~J;nsV}fW8M>D67-il!!YdTul}`o@S~dWx>2ljIIQv}4X#`A
zs{3)J7O+Ghkm!ETUW~{i-FPG}G+CH0%fhZwDUA9y9%Gzfuh*XgYvk@cwC97bQf-gm
z+aCrhsY;9U2)^z!NlrG6g^~WXQF*VF2@~NoIy9AmV&qk4a}VtafF_ZnIgG;{@BZ4{
z<W<fHOr>TUOk(5ZI`#SYYVD72%QYw5diqHn%99YYqMd);G!{>!I_(O%N<SR21FO8s
z8oI$+w0_43;{KvW8&o6j1d9PXhN`2&_!U<pcNU#nM*KKIyukQ?|GeCX4Ozow37#0?
zeg9eTzE!sVd1a!>wuksbzC9K|9!Vck$_Xi|zp0kU0TW{Z1UA}deNm#9E5#R2!muWK
zg(iBVlQ1<UzF>k>4<W@x5rihh;3a=ju9n&ogaXmUOHkPp#72py8e1b9LaH~RoQ~4G
zQSD|Vz!ydlW2JhH5K=a`ANyXj5TaWu(eoxl#AM=ShJH1J=nm1%jna&mg!Pm4a?6kn
zlZ3)Dg2P_24qZJVO#cRiw4-dJsU3cEQp6gG?jg-8FA4BY{46Qy4Q&FwXl(|WBI}hh
z^c%UP!U@e%2O&kQ5--)Wle^KBT7^-h#tBks6!8maqXudgPLOPt>jX)ODN(8hk|<3w
zI?lxGj0v$)e3T990y9VtzDWVZvLT98P=-?@Q|!n{l2nh)UFM`j3QY9K(kK;xkjo|2
zOZBoLD&4G=!%Cu%t5*IsNK>iV8?0A4q1It8BrD--AZBMKh%I2Gijt5Eq1bC-KJ{F5
z!08r0)$=bq`p*<yXyU!Rz@x$z>4VVBg^;XId;Lu^b5d&lVi@;B>UXf15mLRDkd+Fu
zo?rs^T?8d72dPh;@}ls_4>e!t#1e?^W%}WZVW`CoQoZUjhYM2OA@Oo2vQFUy;g8mw
z69`p{T6rc4c@_Gr{(#q`uS_Z#<to*4;KD8_iP<K2GzEqw>o{oI6W{A3fQE>Dv(7QS
zhftdDAjZ52Vs*dX3yBxXlv=%9{l)<^i*naxTBHK0#-3!dj+SmILp}Q=tOH6YiDF)0
z5I=!8{g>|S%4}R-!SG5n=_^U)fNvN3b{MF}>-VH8bqcv!uUMw>nwHOQ6IAA{)`^!E
z`qh-Jos=Mr`z^PywJ%56?q_J{a&;TQX0jODxGofTnxJ`r?CxayEKDyY%tBMCmdhXx
zkymfeSN{aFTKmn|L78S_4Z)H(FFu!rXwg+V#G7tT14ba+O9^S7fm4-f!AdB_@34*p
z*bLxWm2jV~pbI>h*rkvP;Nrw3Ew3Wg0a)p^EgEc;0z^}+Y=Dk{%7bKV!%6nkJ{2;&
zgNzLkhDBO#GYkkr4zbHz;H_+IoO0ECLo-nfP?XpKdIVnlM*bF7ueyaLwwam&vgo)<
z@unVmh%s5U6)YjX0VwPkL!?dlw={#>FOsbEj2^SM#P})LD5I({CuQW=F0<Cwa%=-o
z4B%R{zhl2cT3<m3tIcjq@A@GsotoNZSrxJcq2gK>-xE&#6}A2Z8S9_~NUx#ty9pZN
zC`~cY@1nX`Uj&u=K*d1Kj_H5h)6mT^5k{}mj3m)pMTx0&+*J^U74NX!5SBayhPW0M
z(Q&1cEjPbz{`B4Cd{KN^Tb!yAt)M4WJmr`lw@EMBySyBMW&>zCK%=X|xSb>da>F|{
zdFElwUW^*3S_D9-_nPZB#CT3_js<Y_61W;0LV69O(8F$5*<gPFCxBRUV9Sj+Yz>J?
z4==SsSH-`mWJ$30uygPI>ZljDfHffYE;-?^j`PFlw6u0WWzQzdfTX<uF2rJs$@i#F
z0@Yy<<6mv_*k!9sQcv%VA}Z6!^gcT=N-TYyedbt(CX^`Is(Kbemhf%;;ydi>7f%#5
z&?5w%X7Q}y^F(n(@Or+ZUFHJ}bWhe5Co)Q0rdJ4Zx24?1uZ4c!C_KJUBTU&Rg5u1{
zf-%SXgyFgwvC*$6gKT=H#*^dMhtCUWKTa$VR;D!gDhZ?swE>BGc2vw&V6Ua+D{>SO
zm^j>&Y}}z-x-&a@N%bV3DA>6G-c8B#E<XOKJnw!=l21?2a*+R#n6|sPl*ZE$Krl$R
z0`nsUR!s%AZvLeMz?y{uw<beAkD0>d#59@@L>Z(?sqSuP)^D24sx*R&ex;OI?xezA
zo5$zv(40xk-FW2ek*2e#kyRfC&t@JeKHgNE^RsxPDzuucH&AvS>DIRRL5!1Vo~!w3
zvX1Tfh-=s}K}u!7OK%;2uOxMp`Ce-(ee|=m&+WqCkqaZ|iszD1m0*CS9`|A6g^wf7
zJ^&6Kh2`xjEMsF*-d;qciZRV%+%K_4bCx~%lvZ<@@fRrGt>9EwnN@T78#kd|Y|h`t
z^5vuDF^v^{dX*>7MfsLoST$O4X>Ua+Nffxb>hsUajm^s*#v`GrWM3sBLcI5;0FgvG
z9aVCH2_U_~3j%*tZ6YK0l$4l#LKKvoT@J!GvyrjvYM0@v&V-tSC0W<q{q8m!E?2_Y
zO8Ab{O;KWGoU+!6RJ)FRZD$Geg+wDY@o+9%6JQj1GV$1nutiTM{PC}qs1l^9iFz|>
zE&@dE0I%1agU+)x^Vz3G=b(Ssnkvb~+d)-ylqNL_SN$t|9sADDA5b(zQ!TW>kBlgB
z7Y6CyT6+d62Q+Uh&v&L4ts`r?M`^iowLaLD{g0t@k8A1w<M_^YwsxzwTD9)mT320G
zx{BJ?ZCy=;B-xZCVG)wBYj;@}3dJHy!b%90ZG}?4CL#Bgkn49YUqV0o?f*T_ZfE<v
zFR$10<w(akH5;uVRapN%5y>ESEOVG)5)&rZxjSNV$;5I+%&`pfEUw{rLsOE*ut;Ez
z_;ZCyGU0JeKmKm)YbS`g*!HIlu5?ragSci}gF}Y}kKFIgIO;bG9VZ!2B^P@^&}j@J
zF}cRR%y`WuaUb6pd9lKkkMtym4$&@cSoa`HX+C<&qMd&6LC}PlYijjW*~AR1s>0@8
zIWKG`=-L#W^Xcg1Npqv#c~p*JF<`o9mn;HexM`AbY1hR-j+sz^4cFY<`OA$(CaN^O
z6~CZT4nf%5C;0`}Ses693>*1*zm`L@$iyy%Y6S+JOeX#ft}%t+Dx2|fidz;!(_*e6
zi$6Ld(W@7)f0ikOdecG_22~p5RPa5M1;AGl(VyF8yx@#?K*|3`gL*iFvCp_a{9r=*
zjyo!#on+2yj>7tbObu*EHFie``tB~$G45Z4-@m2;;~?WngP@C=8|QsL;Q4&_|A8&N
z?k<XJ>$u%#MmW*W=P^0sK}};3vd~R^>_ttD{InrwqI$k?Wz#&c@PFfm=J#}=17q=h
ztyK$$D^|5GTGi^Y3f$ATJ<G;o6B%q*C5u))SoPeU34x_4ExP!D^4@t}&-p)gjqJKH
zwk>sh-)<6%{?u=3BZNydp9Fnm&u!lT{(_Xp&)q}l<M=&ei?3akQxX1_PYx}LbX)t>
zZ_Tql;r$Wj{hiBRotgK<G6>uRSZJTQf80H}@%j9^RT|92!0&xm3GtJboV$L?yQl?I
zJ#<tq4OU0Ouw!-}mZ4<y^SfKr(Tzcgd`wZSgOoJWthg|LO>l9uDcX0cU4d%h<9amq
zhv~Q{vQs4&ut=rR9@%_mE?P>*f&e;1(Y3jKUJKtCqQv+I`wB@gou>?CG-<SK4JnZ{
zb3|4Gzq9&Qh{5&{gC`1{5!bMsv)`3tRy1ii_^(%$44uvKMv)Cm|GJ(c85=bl$uu!~
zKTegxctQr>qA{A|KXllHo~7eXL3&D>Fq<?+`oWBO_JcN=TdKksLjLYIg?y;d6S=Xc
zeuZ2h>GzK)WV0c5Z&9<%$Vgy>7#*r^#N?FY)THa@5$KQf5AlAmF1oR~(zr`AJK_lM
z;$Un5i)=EcUGet(G-5p6_;-3%iVQuc!A(I>5X!)H0jxT?+UHFDQTL@i3LJ}eJiN?R
z4e`lu9X1eJ$lA~dM}{RcJ)KT%AR`Xb3+o!|bSV*op++09ySdeq!u@Uu6x6lBlQ9P!
zES#)t8zzV9oKFaCZ~I7MtB$*@PZ@ocI91{n6Ou_Ll-vk!Vjrdtf2o-wEGl_uv-{8D
zb>{YjDqPMhhfkp<kxy``wUjA1H7&cbS1Q8XD|Ky{AX6j%y^c*DOr&o`#$$(hI!TWt
z_V&%rsHwRKYj4;-_ef7QB>z_FJ#41YNp9Zc(3^iMuf&jlF;Fsp0emqkx%Ea9=WrEU
zW4P$*_jjfr(7`u2$HgiAg@kziX$#M^KJ~&<q##zFnCy~<r2M`AO<<9|&wjPIeY<N*
zk!=i(y-N9P$B5HUZVfaXYXf~!(C2<!7q$f3;jJmSkni)tqhd6m*6ruMTaq}?TYJ-^
zDSV3T*;}WQfb-!?$etZDH|P$AH9LlkY${pB1)v>Nu*3!lJ#3u(-~r03Nl*H4PVNab
zH4S<37LA8VNP>Cx+f6FUTUo%`!V5)#w@rg1qm(8sny&KQ)A39T29eN=_SjeSb<);4
zns>Y8)#*GTy)=Go#3j0FM+}i|^c^6q+CxMpi1rCboLql&MVnSUJn48~MWfiU*8Zpv
zENNORWm+fg=@|}#IpT))^@UG8r@uQ}KH}20Gppj*t6#?r62?~XMCXq*(vL;;aK_eq
z)dxo5z*KG5Nh7bdJd|fOXG}M5r*xXHUqIAcj>i4oh5%0X|5hOllNaF-7k_SBGeLLi
z5RACHw)aG0oE_z*UPf;KP7XzUZ)0&`WRyEqVt3og(x#XLEw(ptRzvHNFeEl&l^RMO
zn6n_^|GXKw5o;1I9HG|tyvxO(V*Xr_eF9HVLHEs~Si-y;5SCXvXUj2<&5c2iO`E1n
zM%;P>y9Taoen-{rMpRuM-eiH}dV6+fKYlhkzAxT?n+4(Ci2KUMBMh@k+Aa|tH!FyC
zzBIeWuJC<l6ksvFNp)$Y;A_pxC8!Sas56`HO7d*)s38~kHhf<Ut&=_)CO17Z!P?tr
z(wb?P8^30|AJcBp#Ykb>3ZtpAFVIhPs#DQzr%pvpq}1l4eAqGWQjIz6U|YklH_8cy
zkZzLP9OKm)ethRhdn}bPuMa}`7|Qyg8gZ*{R8@G138Mf(HM(V(Qt)OT?%+A?)NNP8
zDxV74&iVY}@^j%PD389PDYuyx6ye#*2r7+$rMuG;@>THctWH#n<(kDA?*}QKfYs{k
z$%P`56n9$Qf^}xOKCV4?9gVoMcw$y!Fa5b=va*6R)66m9t2_$06|BJHv7JKzBT%y-
zEnkSMZiw(OceZ_yw#Fpx>J2Kz8%6I!n@s-#(LokS{Ln_Mig$x*<&Dlc`8g&$zp3Wv
zgw1K4(ow&02E8`rmC-p`f(OeSyK1(d)6vYqYOTGFTG*u(QG#8_spsRw<T#KFWNTKt
zihm5ob}NCgX1d*My>yAJ6U|-&u}tl`9$#8w3ZJjE{`{>hGW)azLxU^x?<`v}D>Qb%
z;)-kn%OW`0CX}i80noqV>P5LJd_;jt*-;wu-*L2cw1R9?GWfmYxJCE4oeBL__|hqr
zIiqyww#|$pfzxK1kdmCA<78Fl&R^RXh@UOw8bDS-vZ3?TPHkowtX@7T-C&6rhWYtf
zML5F>)24?+hru-F!q`f<S0VmVS9Jby^}Vt=$QK*bLT4DC*LV>@5o+=&I^xcXhcDV?
zk}n*lmn%+SZju=IDUfTbqJiX#J3wy36m-$d4UcvnwB+{(Xc{Mi_Cf(QWhsmUsRJ;l
z%u1F%0!8I=1Fyb>j@ctKbUV&On<STW^hwLfhgNx|2@uJ<FV@=!Dlsn<7!9fz(}_e_
zr)U8b4qC!RCeB1MBzsFWXKqxp5TAJi_Kje)k`{5>lUKsc6(S?JuPhKppe7&b3)j!`
z{|NIyR6diq6A3sJbM4R|H=}++nVDOPiE8@{wP`!MapP0qlLtWPXWwWIl$CHgpoZ;7
zOtF671?RhDftGZbVSgbMrS8V#t&(YJ&Bd5Z1!k#kRUCrDcTUCqII~ttFo~S3NYwKr
z`NW&l-mL;#cM9<YQf0u>ioDO}lZY&&{Tlvb!ZUZ+We?ie-)gA&Gr;0pwlWo#EJ;GX
zGV&UlXaAz1_+xJgW_S^Rs={GYD**~6kYSKEiSfj3S9JT)47ONXP{0B6Y#f6hG*!(E
znuHN}gER`BjGk3EAL$VwSqd?(l@U6Tc+Y7IZQ}K&mO&HbAkFHYQ2E2h)AO81rNKNP
z0r|?%!%XhsOvc8k=}w7(_Etx?p8vw0f~OX>IG$okrRLm>2h%KE+!B|IPDH~KWM2JN
z>z6Fh!F;1jjM=#p;^QqOqgT~TU2GViyp&i5UEw03^-G(;K?d=Jrey<mvLXpb2JL$o
z_5OI_?yH~oMzKCG4_Gtf*$Qt8xSuYTa1G2$Auv8J(%IK<F@2PXv&1oQMPHIyAXDZY
zap|^M_)7k=af6D#QCK<^x^#95VIfsm%bR?RWXd-D$+l}R_tjYX3N4OE`N%Aw7egGv
z1B35au{rbpYgFN7hXykdsqhALKCl^i)3t}T=tCU^plRP_DsIIg*?5bzHi2=rR<Z=?
zV1#N=AHdV#8P0lnGlpppPVY{d#X@Tp5pHV&uKmN{&$lHht)|+$MxHY<0YiY{ZOuEs
zOy~SFE-)xnM^X#4wH7JqAMueJN{MMCU^B_j<OCdeVAs5Sk2d#U(WD4oc?pdS45!WU
zpoo^qjU{}B(H4a`diJ>KW4zKz4VhKI_87+Dl#ox(0&E~j)u#<pR<3k0qE9>Slt5tH
zNut<UsHu<j_~Jr3fLvH;mNDUCSQJxI>w6^R?dyhH`q^_vC<AIDg?bd^m03*73?c(T
zFAn3t-><@Y?(!9;e?1EnXSmpFIsUdpn-8Tl1^$&K%y5fbL@Qzv=ZBZQ4%Wh41GPqP
z7X;5=ihxf$uQps$`t+gfQ^CIe76<#`FwCVrrM|)IcBWFow+CursXi#1vCLjNXi3uH
z)>lLJ(0rT}{@$`Z!}W-Z{*=Qc>;`R6;eE$FQd<HWTxEjtG+Eb!gCz!Ryo?J5reFt1
z*xlx&7##M3Hp_)fA+QlS(jw7vOM)C0B0%LY39I;#WvPY69bX@$fd$hIc7zegT1a*z
z(whW$sgVv_?Fee{f&$Y(gDsN67<A-Q!fu`1=duQqC|hN)E*?)T$e|;yZE=)UC)}Gd
z=<|VlZV7zal0SUO?jMGG$bSeF5`Ew+)K&_N9oV?!!bTMwa1>))>A(p!#^#5(mxli5
z9$+Nh`w6kRDR7C695gBcLQ60?3g8^A%n66Dg!6Q~c}C-l(nvagRyD5=mvp9QoeDxd
z(~u-nK;~;BEpbq8ID(>pn1^95$SV7MxQ>?*19GHG>y{7><^lwMQ;ha-pqNMv`ntex
z42rB75wMovtlcWtni$JNhI=Y|XjzZRPV2v+s-$ofiJeW~7(&9cDA+6CjA!p-jNejh
z^<)w@`kV&ct#R7N+1}Q${X_&DNkabhhM`CXQ+b%%ftYUk#uHM=zOMMoq#6g5RlQVC
z6?9V35RBug?AZcCU)23tt0*n=jI46}A?oGKPJz_cgbt58f$(IC`#G5QK=#?Ua8DH^
zkL}V(^&p<Ew)qvAtOWdaV8R9roaI}ozPioS=$dnEg9-{1^9G&a5*&UZ-fFnAD!|f1
zj%eje(eLO2_8ymm@V;U<DL*XTwdRZ#5nK;zQDZK#(Y11fvCRIvGxpPxpdxib1q|Ry
zz4lsK1n^M33RJ~d<|(;#WG7#p4Q>Ak92=~6utbF<1^G$@UV_kHT?mFMse!(k;UlDM
z0WuV}C%ekS73(fi0Tz4dZ(qEn6n2VzSoQ^#%-b2#iL`A4)9)h)bg|*_>I)Dnm7IuD
zFX^DcQ5tx{Rs+aX?N^fn0b)$XY<wpjJSB81)<&Luhc4tK^g8XXQeb4VBgQg#s|@!8
z>8p~X-Zoo3)HelVI&`mkKD3!#M%-q?V7HQhs_cR$HD<jOijt$0I8?!@CY7S>DDwEY
z67YG04&nJV@PWT49C~LrzvU)Qk-ZxDkf?k9=m31$+lATms)v&miUN#^80mKt!u7=z
ze?=W5CA4zvoOU3`SaIVlOfo0#M;_9z2Z8zmYEmfY)XVkujqCMQnxvK{UQ6`V8iQN#
zGbHR3K8{WDBdDDlq>F$p+kRZg|5fYaNdXu#%6z8;86K7OmTi2c!Q>sLf)2y54V1J6
znW?9a;ZVUlU}t#f139M;Tty2=64#xl22D@{9HiH2^kq8oO*jt4cZRKT`S%+tL1P!h
z*Jb6d2(!F`@T5T3^1}?Ah;PlXxS#uZOLI(chbjxvRpl*Bauf~^^}wO}G?-pC<}BNw
z4h9tBF!hC}o3wBnpMz>=Jc{0&k$S3$hmKhuH1)Q_!Us)>Ms9nD*<p!KKq5QY=!rsf
zyBt;SgNst2lq6a=8@-xl_1(avpuwP57HGl`?Wd(Nj$2i!F(+k*9(SSYULC^rAe&u@
zu{6woIp<rY1`<iLMT5Yh2GRE)Tz(pM=Qpam%<B^8NTLR<k{tmVK<{IrgV=2&4%@<x
zJ*`C9??NN;L7ZBoqJ=!n$8_VGTp1o`crC9|(UHd&Etc=j=0UcRbh`>u;jqMxCG!%R
z_($FEqmnD^9yxV4(L{j`C4Dy`;x1IAbV(vDvFcVyJ%rSL4}F;}%WIb8YvyCxH@f5j
z>s^S?5X~kr00B+ZyeE7fYZ$E-l4Gu@l|YD0x`Bh~)Sxfn5SBqOgPY}^Ry^&ai#=*2
z#<%feK?O_+ETExeIX(Gq*hN;A149^QOmn>ke6(Z7juO+j_bv0*VV2~?otAk#EimZQ
zpI}Lp({i{^5Po%e75)pPCJ+^+xpuwc@STIOc#Xk18mU%$VFlf8S=at;?I(1lt>s;Q
zM>KjG2`rijrkb>+OtC}dkTvGjre$pylEDWCV*5|swMb{2z1}<32=i8CTsv7~I|Iu$
zZ=Z{BzN|4gwZN1+fk{%s0;JGtPT9HlJG*kiF0jwQzQ9D$SB-9;>5ritoT+<1iQX*R
z1uue~#=}Brh{sb&hkY#lIut<~CH~&owXS$9<a)gpe2VF{qyq_Blv3(v{}!})eC~yK
z&1hx{y+ffl5e4wTjdXgIsY~7@o}{l*d2$p6$k0Ze53&rPp^(9yJ^EE*bCY3%IR!U(
z{SS0(ogjzZ)g?k`U+w?06!mGk%P8|mDto!#N}oPgVlq9aJ-Bgq(T)u_MIqJQ1YUgH
zyr!4M7@-`7eim!2F)iVNA?8RnMF%8lFc)wJUhLb~cMWtcbG=w&<<1`tVyEO~&mX(h
zrB<z<xnY2%19VetL9nH-0^Os&Y{8T5!S&QDWd0-2C>|J~g#>();TPDMKEdoe(!7tp
z>A))ky9HMcjQkU&1bpe8PgFjLEhrl4>hh?>d5v~P%i%hy0U2?t_{P=53y|3@m|b=K
z7yndTwr;suaOk8O7Tmh3*_nKIqQ&)R%Z+&_sW|kN8Uae-bAiA0u618}VU=43>4Xec
z7H|(IZTMUbxU<0`4bME-lIVk8J9>Qk?fxEVD**!Uqhs<F5D$O5pVw@AW!L96w3QYH
z_R=vqa!63MDNgPpsn9)G(NtV=8G)RsUE+>Bo}(mI0-E_KcRpargA_h$*Yj?tR;ZjC
z0UyZ5Ozl|5BZ4Qkqp^FTQFv_7lAi9j@sbVD1thr1!xgBu2P^jR!{ZKS{o22^BL_==
zK=_}rF%8j=!>s4*H(}?syg!%CKP<jBA$dAcs~mIHz%pf&SUDcVz}NTQln%o)ofijb
z$OqZC>S(PmZ}Y3!u$<&4DR&N=7Z{xQRGzM$_k70%>3kHW)T@Wo^kl%`k{VOH>q1TL
zg*bJ@3f==S@Y(u?Y!-%ew6{C{4|LV>r-L3HI+Z~W8(pn-eiKv7*3i-8K#E7l3*Wm}
z8?7c6T~qYx5GyZ{dU)Xs6-(xA5OH>Nw8QG|v&)tWY7@!bf|e*cliEJLsPhiK6!T9H
z>7RYq*i8@*r1T&AC;zw}wQ`jsLbhQN6<Y$rv;GW1FjClwZ3v_kVoVCy^^F>$KmpMp
z3kK-D-U&ENpB$zqYLq=Xc&rd9io15{&xxLu8THk;4GI9ue&w%#zoGOJ<9l!Z0k+ZX
z7IUWOv(f!pkF^nFV-<wRbDP#(d}XY)v7zmFEdbK`A?XPhuS|kSy`D?~<nwG#2|>3l
zV5D;Yho^@_ZO2>OW=ynkPbh6Meb-eacziqz#|M4=P#$uKksM;f!x>)Pe=TBl6ki81
zkRdwbUf%S3Xu9N~FdT~IL)P-kH!f1~;?FQGVRwtr3$)4eZo$JIsP<fZ#I{f>)hK`Y
zt6)#~v8k(>GI`Hu*hw0eORH#FGANA)dfs882Hwt>5iKA<I%MN^9t6vQ-a$V(GqJFi
z19g1#$@exioex=j5%T6KW&tNEJ1ywK*(D5qRz2yxi2^QqoDJRs9&fo-9Cp7|vHgTm
z#(lu9UyceU&D4pLtmmVg<q#7dqMwf009ki$H_}84F`zdeqhBP`0b@CY#?RWpg9Llx
zwsGwnaXZq|L9&V#^>p}{O%w7>!zC@4mhde~0e_riu_=F71AWE!Y8_09!yc2v9B;i&
zRKVw&M%ohQn~8zA{%@&Te4YY0d2}xyzHPoN*XZ-8x^bnY%-~fg!$4}#&AW5;Kr?Xq
z{P)Sp@{t}_2(UvFDyV`i#VvC=H?{v55TQL!mI8fanBOkjvgybY8Y;R9CDtG}(>MJY
zwew`c$G4ykrWus*kadu@5)Jb80id$(b!bHr`qK&e;cKbijkVU8T8)7ahdRbar*n3i
z>vM|SPU`3|Hy?Bf4vC;($3OR8hV=3NiRAN;6&%uK#qSCl++Mx4NrOoz%ngL1Q#H%i
zYySu}2DKXBdR`Khw(tz;b^e0Xsu%rMOTii>u9Kqsbx2%cagJrrWR>3da0{BCY9ZmK
zH{kbS2s5*)i)GSdkw+42h1$FNOm!Dmci=(A@>Y690xGsaNiC+dZ~9d&{c3Lz)x%p4
z9YmU+Pe0bkmT59-XrZXT(flnN9v(ib3!&qGY{3sLIgp*%!_Q2nc{*D5PWrXSEH>g6
zPQK49y?Z?Nq|@WM6)~m`A>sunNzH?|leLu3nk{B3=aSg|HSu3zE{Uy)*(CO&2lLDv
z==Io#lzhf($Mnno5#_!SdW(UJ*Q_k!9qw3U3-4?W_ZyV3R4HT6){~6SFP7{*hu{9e
zgcQ|UbR|a6CCZNR;<RSU-z;1Ca7*E>$Wfg_s!r&*(fc=wobc`Kz1__e?%1GJbB_~n
zIDZ4NzSc!EB@Lr2Icd>gGdxg&@tKuXau+NZ+|P<E3kSbuJ|&xQk=5l;>ZazChEspv
zDG#Q{lu_l;F_Tn-`*A`AzDhWWI*IM#oi<fqhbv6#sHH6@?ADA*dvTCMm|B+06|x8$
zsGt&;QzrMDbB)$(g_aQ18<W#MGJ#pz?2LkHp8f81UG(p;+trl#<C@a=v;`8(Ko;f=
z0hNf00nrQIt=&iP!EsM5HX^qW(hBcQmzwOa%TJ7%_uo6AZ6V5ufDR!>G^F30x5<<%
zL`60vF7}Y1QKZ?ah868Hg_8~`S~1v-&GG(kJh?<UXkfG;C6gG2{%`%sjJRkHf?L#i
z+KfA<ke`k$d{=J4Ew(%<2d7z1HLy#pQv^_`k<`28-iDy{vYAU3>$$O-Do#%HhY5%6
zuOEyXojE}&WffiVf4cbSOqsyH3OG=ov|4<}Ky-9gBM({}<Yb8W`!1m&b&#)Mcy4li
z@FbCg%Bm@IR75n8Ok5lfx#4Jo4XoTA4b=RJY;D68q2-%{0oV~K)Oi`c*gU=H%b{9_
zn3`{;D~s^qGqqc0rjs{h1UWV=YmoAVHngCd1E)`EvW;4G!=!0$j?F1N(FcM*nDIGY
zVZ`M;KHh>&q&pnYUCR3+Sr<C1Qe5X)ZS+r%)kO=8xxCX}j&eigk7v2DhnP@<dnu1C
z;$sgvHbhn?|1pRyw2UNXeCKe3zj`9q5Rbw)8<m&oew{VXNb&f`n44UEycLr;6sAcB
zJ>iKq!T2oGPq+~oJa}%zzs^3cJ~=M3U`5j#V%)$X;|@6DMybia12+z?xXOI6pRguQ
zR-L@$b-+Pd;TD?Vzq^XvemZb(o800ImK@g9EFdD#EisK3#olF|jZ`2{5g}G<AvR?k
zY%4Kx3h@ZT0N<IY6i0tp{WP`;XKqskM&jaNm+*)I!M;);FOURd+MF=uUKMDd%K9!T
zbm_oMxNe<Ir-&F$N6BQ*-3O(uBw~j7?geHtws)m}auhV281dA^xr<FACpuFzEaz<#
zdgKaF{&`S~E{?Ev?k0w-VG?JE#q;C1?iM{tVmmJ2;{P(LR%l{vKNQ@e6#!^g4xcEz
zfH*yyS(qVH!Q*fU4@EVaJHhx&m5bcvleh}D$h?u=_E<WJG?4+8Ep!2)#T((=jJAO0
zA$>9#JG#hFi*}r{E|U+>2y7u=p%pt6bQvs78E}ccBL0#_GDxEjkO_5?Q%zJj;}G1S
z<rdVf2#CD;fkAAS!?u;t(GR9YuFWI_wSfv-s$rsCAQGQ(Epm+>&7G@*#=6Lq##KEc
z^A^ac!&(R;Nh2h*NDb&RGV&=t%e;pNPAu}k@JXQ6Q7x!<`vvdbAS71u&k%WBOlV*d
zUr%NYadE+hH#E>rlZu_+c_O(op&_3Ib&`^et26`VT~bjkkAF055opzgyKcINukXS}
zolnaUOn0H-N}lRN{v)Vs8yCN`O=Z%;TQU)?XXDBoe7t>6_uHB-;Agj0`)Gx3rDR0E
zH<Q>xgY~mz@D=od<y|sycN2)_W~)}>2L$@C@Tzq(VVj$yVC~o!42!mGSGpA5`Bl$`
zWF7gPMV5HDPZ_0i1i4bqtu<5Ln3=k_q3tw;ZidipP<LB_YEUdr)7OhD8?yOT3Q1s~
z5SKwZm+|0~$Zfh4;ju3RSw|}l4pbR$`Uq^BuMyMelc43sXSoxFqyI4Z$Q3<d4lkq<
zYhp1NiGvY(-vw5f1CCg_ioA~I7*hKFT*YhGjjs<uLxt{G`yqwXR_QeZcP@rsDk8Mw
z(nk(28L$qCL!>UHpmUuZ&kE^f@x7L$<FiytmrgFLXv*Yn&YqiU@OO*z)ZV%Y>RF%X
z@Q_H6GlR3t=}TT~N=K;KeG{mcj8QuOea1h}i8r0>PV8SooF<!ELM>zrBci1%Hz&pj
zQb*nYs>kx$o=*sO+}Dx=xwXrJbS{G#-)Zm^&02(h?mGQNKO8$Cw8(53U0D@hx|%(3
z-f_hyX1e#`-Cx&veb{*;FJx<-^Yd04`HHca1cuS!xlSKukblTObnGTsr~8>t838QD
z5zE~j7XKc)dt@iWh{JysElM3Zc<}APN27dix1b5zJ>KU%wh1f@j@+=E{g3z{3S)ku
z@IG*OOGW%!E~=ORKzwez(R$IwAch7OP%1c*B+QMfx4eJ&VS4Gljgk5F1;GRk9lc2l
zAiDoN2!8Q1G=&f0+mql;#7N6?@l!kOS41Yv-^wRyg~qu~!#1Z1Zg})h?z%)iYUUg(
z@-4bhaqHBpX~(WxNffBBtofpj5b&#bnE5rP`t_@>kjW9h+^z2f3#V=SEr;{^zis_6
z_ljol`_9TeHS02FX4cN_ychiW>q(16%}b7r!;xHMP@TZ|cxQxZTUK6s?5d9$t$}?d
z@!Pv=oAlbM!Y9xFZtuCZ>hsptU6%3mlEI+MpLe~zX6ed{NLQ;YZnnXjpS;*H=$!tg
zVqMWITV26WRLB=HT}6Q~vWC}%e73}eSyMU>FD#t|eIFIQi{D!~-kSd3nRWkr<*F6F
z?@s?gD4|2MdE(iw-9N6q-Tm)wot~o>`h{z;=gYPzV9a{;FB>WSo6?s0cJJ<=L;d`W
zOs~uD=jlETh0MKrT`c&#VfEZAXI<#jBJ8Uj*A~I_(5kRjoS556*AJXr2&&D6S@V<z
zyxiSiq|*CeM{vy>Y~<^qVpXVliqJuQ?Ne+&q==6E-q+8a7p$VXW(zJPUGvYDq_8C^
zTG5GDe0w5%d5R>7B(a!XgiH}F(TJ>h^r5X%?^$uMLWcZ~GMNBu`Hbk_{Dpz=JFG?R
zto;rer4%FZyvA@$Q@uE{uMOY8(ZH8$L=MtxpOKPy+Tm!VeVvAHI|I@hF;266zwpJe
zBq4TuVMw_+V?qq)Fl%v20qMkErI@Q0u@)>^jyif-8f=6FS#-BRn{ej%LL>cZqd^>B
z3XgvWTFuBgI`UPQcaZn0YK#VAMDoIy0;c@NXk>TYEW}&}P+0r+eW1B`pGY3Jo%*1E
zK!3FOO4Uk!SfHgZ_9_MvdMX&T{Mm){(YB?7)y^Z9R&nkhkOyOutylDhR*gWGC)Weh
zH<nY+V+$ZIG{kb`F%I_B5$~o`#O8%8erxT~jokznWq5YW&7-DQj&LDftZFv}pHm)Q
zT^ngyUbDWg1*_m6XojvG4Vs!4F0dJD3LexW)gtJ8bGAsS7di9JA$AJvCImkME007A
zY-a@)G=H={^G6HVas($GD&VCe?(E<$f_qY>A)Y08&$(%~H9GSe;I*sk-7kR+q|RAq
zDyS?HB-gfvd=XfuK$u!dbWa4u)YM)pu)+Zjb%yv^2wKWFofYi5a0WBPu-6WM;tlJI
zoVUOEZTZ8XVj;x=u$~1hvxDk=W6x@DUycRvZ86mZVDXX5d!?+EwO49q`2-~3iYrdi
z`qYoMCHxw)ky;0R5#X=FKpbG-;P`b*bX$(ib%MZrMlc&KIE(d9xh=3k`VMrD*hnFs
zT1jGQRNKelV^p8L)qL|=V7RVz>M>w11L#3l2sFU&G1QzN`xxh>9*-8fC%ozn6!l8R
zzR=q48K2MDZ#^VDTOs!D379DB2rd=B4HQ}hmf=!_IakHeJup`t2lx<H2FgUWU_|s`
z!FURE5GM^Ng}HEyW6J~qY#1d)7}+2Wkhvac5V-Y-{FjLAw5?`;479o8SdGXr<w`9{
zK<W|228x}L4JX{IG1&rIpg6Wo?M<V_O!6&x?RG9gzaDX<TKGkda%97zvf0_?C;ZxA
zj5=oz850*Q^yi5Dh%m&?N(U0m*id}Ee88s%MvXx=_K4i2Au`ibfou`sj)+1RMW=`z
zhngNE_2z!{r*?q!RS-}BW6nrcXheZhkw2eZ+i+f6DW=T`)^p>y5YUPviY19#g|_$<
zQ9z35`GQLhGMMj>{yHLxOoXr<Z`G}UeVP_wus3WKi9u^C#_OWirm17KFlWBtTk;W`
z6qu`4K#{STQX%uo8K6mwj(|}D?;5j3fd!&}Q@{nKuwWYWfMOoB3G~wfe-<X_#gehn
z|BNj;f(smq)wW{_fEa1Bh)|rshB{n<*tnUc^+=|NMSrFs@zI89fo35E38=)ybsuRz
zd*QPSE5TAEmvh)RywaEsQ@cv8;2PqI&d;L-VOsd=hGogp15a*4s~<m{z9*VEg7#LM
zHP1-?9a7V;!j4{nZ}N-DSXcvUMCmD#Vw>fuv%>wqAf73QHo}{N3+AD+?H~PWbs$PI
zQbd*a8vG$<0;PDNZef{YsbpyKq5I=AAX1V+f_<vy2hSdCe13G>!b|#qN%a@WS-j11
z*60)|u=HY6^bjz`hj_9Y=Z5yD@}UPb!qk~^k&T`*d42Oo_|gV=eYVk|8`T!s=Br5{
zVibp9!7`-HS5hR1Ct{OfKB-6IMOj|`%$qtZ9$HUm9vY_~7K&a!<RIn$%K=vtB}-=X
z?>TPS@X8Dg@>mnxr4)}396E1S&dJudZa^4hV*Mhx&~Mq}rsos%Whl~;yYJvW1!pib
z;OYhmD;vgSNeon_^i&bI4IZx+E#QM}nwU5YNty*a9K`WjV-NMw?`d}zjqtZEx>3i1
z#Oc(}VqJtg7gZY13g`GBy(hhlZGq*9IdVy~-dIhNaAw4$I}le^<6;dg(#*!QU>;tN
z;UvOCwXjI<+bi=Ah^E0s*`ml<kj@{QD1a=GOGIovo)nBzfD5ni-L$Ji+F<e7gjG5F
zg(;H2#}ofusXxsZF1h_In)Sp6SDpkB`!|3qam9Xt0HOh0T?!HzQD~Ad8j0vSU6<e>
zwB*Hxj0pHA!5A7cF&kWoL~vZIqG@ne8!SXF{t*ODp`eR~L^+4xdWl>}53IQw*kp?e
zf`ADVp!e^{Dx!p53SNH>HeWd-Qo!jwE58;%d~t~74PZhbGC{`|D@M@fw9+IbxJV6F
zPeONAni%E5A3PC9=2gU{3m5)?1<62_E$r4B2$QzT%o|K-5UY3xQsrQ1n}|i1q?bzi
zb4Bz2R+-&{ExcidmahJN@#O{e%hr}vYwf~C<HoimVMHJ+m3aO%OO(Q68Ob1EHf+;I
zQRQT6Ge-=|4j~_bPVj{nO?|)~t0>L#+KCtW8}A;-UmizCmz}NqZdM-2@dg7ip%C}`
zji?Z<92|lYyv1NjSepbuD<D`R_I*Qn_8Yi;3LmZ(o~=$1TNW>-3*p%Z7H+V?UV^Wl
z0rf;uJ+-u`)`@HfH_x8gON6I!;Mha0_jD_uNBEE!T=Dk)hhVmVULafe(VEFJ^wlFZ
zTuN7xg!}p=N!d_j13=*bh#_H8k0h|+ar+1~QjevXI%|V0UcrK(acC-we}M$ud==t|
z6Mz#~a0r&;N4!|ghX+ErE)sL?{N_o>bGf8%Q$MI!bcH+0Vcmh#^>BmYL}HcME}*#w
z9>Sl(M2fhjVrU@r=HK|V26(?3CUOzJ3FgOZCG&gvpBvz-Q(zzqLg^6?RNYG4Do*FY
zt!AxI8u33>cKcSmPFINS3N|1}-Pj?)!N*v{tbikv_?A|mE`nU%Ej-=rd*2=2#_0#!
zpoSshmQ`8*`u~%q%OYB;;HiA!FqiLkQxYJjxpEj><Sm;&(2YxkZm}pUHDJ{Mb;Z@i
z^2p!Am;b<?`ZofLRKsEvV*lBknBjG43fp~Op0g&DAQEiWj=MELeMx34(uX&`@7!m3
zOkDYUJ|tmA5?i3$ONSWUoAI4pwICaq5JlH2II2~mfaEggK$h`cs7IhUbm!YdEj)CB
zMMc87NZ45?AFH+-R_UEYK0J*rahuh;X+-XxP^1i6wC@m$g$SWTd;>L;?=Jb_dOLRC
zo;q4pHD`*#5q#-t93Pn5u5YUjCKim<Dj??qC4FB}Saxl|Ovm22$fKJ8`wyv0iLhpU
zyYGKU>?X?{<UvNN^bC;l#VLH-9{5VO5Q_vBZ-3YLBQI6@8H9l29|yo$VQ*E`<Dj99
zzqI>u>O%hg)YdGdMxl1?%2KBu3nn@k@m9JidQs<j&OKVJ#ruB~e!R-fTFHhlm&32J
z7<yCsV*k>usLa*;%_zRqDXP-Q1-2YAv2}f20{^=1P5QQ`b>-{(GyPGB0COaLU$jfj
zuS1v(_CM1ncxX0s*YzKwz#+V|BpnGV+>D|MWGii$Eed!-wjORW%{&E*w})A`IJ(aK
z-0*T)8vC(~Cpm}*(@G^Fb^9Dc4>eZ_=CnJSwGs;beJrtf;J27F0aA4I7c3f()dKOQ
zaVU{nU6)C!z*&ELLfCa@2GAtZ=yffk?t5F6joa#wfO7tejLxKxf-qE@P#Ohm&kM1v
z|2}dqpF1lCCj=|x@U2FIB(-ryH9w#Mo~|)x(!$;d_&zDyuswVSWafc@(iO{JOP5z|
z9RWtFoAa*2>Dq0aTfOiUu=3W=P0P0rdks#fi4A%nzWg7tL}P@@m!%D279YG<0>)^C
z9=iZKZQyfAnJEsPs;-D+N$NRAw?^#P*$>xV>?!J(Oo;f=8p+P6_xv(REN9=nV`6`t
zk0Y{pC2RjZ`~TtVjY1(UU<$a>9gmWkR%|4sXocT&|Dmu|U)^busF{~<0{*_e+w`xG
zm2(OozW{9Cf1+mp99Ak25hZUecE_+rTYhl)ny`vTXK5RX@iF>H>w#h;i>$ygr0HRT
zKDjEhfn0Jvi4guwb%4oiP2b=iGBN$(p<C>}1(S(p2xu6VEp95$yVp!u*}v&yK1+Ga
zk-LKsBNNUuw?bJSV{YR|rcl9vP{#@H56cc<$!U{0nO}~9zMVykYN<vlj}CX46KNe&
zPP-93ZN5l8BvDy={+D3&XFotrJ0VqUb0P1erJW0mIGq3CpllEmH2U5#LOcMkD!OrX
z{O7;aAm8TW31<uaK0G|PdZ5Z<m;a|Hmo~rBMcz@~nvS$F|EhdYaWewZP`K(nc@nzy
zO)$B@a(guSrZH{vMH!zAIHosMrTneu|09p~_T-GxM5NkQN@9y<?zf(5bUD#oOe=fT
zVrTIXaevqZ$5TIpTP)#+dv*7I;R{Az8^m~(%utUyZ0tLUhkM8XQ?Evv<_Rocvn9qX
z!7m&j^o@4igu$(b*hu4|DGVvCl7h7`UYHLUmVon7+jN<vFxDR59Ts8{URB}HsP?(-
zQTuU6RO$J(Jkmj%onQ@%dZ<p7s#;sE*qisAa(}&!qXiQN7l{Fn{%Krtc{r-pATh>U
zLJ6Zlek(U5E?Ikkma_iFf#oN3nk^`dg+6=Hqo?HnouuSI)6>=>lOC;#(ySS=9a%Ji
z<L+Aj1P7+6$71!jFiB}#yYwM0t1ph69R}GxB^Du`96BN&Fj?8rd5dzSqwCzKht`EU
zPI0WWS0;o(jSUhoBGsr9F_wG$zboB)Y__PFSn<@zj>&z_an9>c2EaUfdhtx8u_I|k
zO3=a)tKB~)EgtRp-zo*2cS$@6i6q$IF`l*jr&90;@eK??rs7b=lOE#&)P`P5_Z)|V
z1;^R3mDa-tETic|9<8}sD%|42=kCJ&Ag(QuUX7GbNo%i6-S#*#eGlbvp;2|?@a;|G
z_oB%AlE<P^X;UMP44vWt#9q}xxp|o2iyw7k&%MDR4%sq4_3bb}>AWJz{Xt!%yLwHm
z$Htl4R?SOS9Z(pq-1gso$10`P8usYw6bMiKW-=0|TSz<5Y5@Wd9iN13d+&VOXAokg
zZ1X8jvLSXRp2g<jDx#h9IXS$`mC9FL7w)HD`*iu$(cs)WFUE#0kZ1Eocq^EBF*N=t
zk2J8+7pMo>ZDSZ`UmF(GVtw~tecMqt#=PkHvujhBv0RDqj9QD!MbHB0qLDV>5k+2K
zit1O6?nV7e#b57dsHMS*{m`J4Fmo3vU_MPIo|CEso?j(?JOpgBEP|%^#t&wzJ$Os*
zS&-C#kwOQ-DTz03FAMWAjmX_ygtLA;_H(~a2YIt4iFubdi3#bJZ8IE(z_X+m;5}M<
zYKrJrFP&<)rP*-&D&Hu^1RJuDBk5}ZuV+8%_GB2wB|SCvkU;=M3uD`=KZi{U^D5{I
zWv~Ukqg0;$l^2m<M7qjK$P+Yo8@lp7-2Z2^1QR+GwK-|>Y4aSSr=pZmkVymJLQZek
zGY!;4&8(V{LXgQ^vwm$dB9UjXdh|HjaFlQH1V?jfF3-S`M86=_5cC|000uo@d+9RD
zQenI;YGP1_b)iGI#O+YoIC)pBk6V+@54g+=zwSem#*fNUAE|D*dFGWJy#qDWwN}%K
zR`V+o(wJtKIfI)+aHTsXr-~;p*blT9SFGqhjt@&^q2F^tR<^0kUSyQc6*58{KvR9x
za>Jh4SI3ky+;q8m&@m<tvqXaQx<DFoapL->@l<JfL2$-`du7q_-eK4j5i}q#{*UjP
z_3d1`ZOpRyWnYh*H_Kf-iVt2^^46sH4?%mV`hzTg%GBu38)r{IQX!YEyX<nq(SK5}
zX0HzJLn5qj(vtL93hrB`RsGQ)j{0DOqD~Fm!~b5H^!u7hY;&XgOUv>Eu$gSZoA8Lt
zD_cBnhO$wdpnb<tP#>3U!tE5;1MjSm*fBRHQbOK<@7bICuX)piZm_2ikPK24I3=wz
zNs@$in{$GNX2T;q7Mx31_&!bY*ya{hrmuPP2o1#g-P!9etoM9CNXIeqOr8YRE*Ll8
z=`!hEvEkV(O2Cyf&5hO$f}kUQLJMV}i@}uI?c1+!Cb4p?K|2q#n)Ap!+vNzVY5<eo
zcE+@qbCxZW)ubc!e;xmeLZe^Z<tRulC`~v`*o@*|eFICMk+8mQE#pw%uCSnsoI0OY
zEN-Y|g#+iU?=+Oqx5!L2pCt2^2{_fKloowFEfrdBg?J{gI8!PQ%PK{ozo{y>^_&K0
zc@>;S)gEki7;VkRyY?@S8<q(e)VUShG^8+fYQ5M?ms<@7WlHnKjb2^;6zuXMu+QOF
zI4y2?fPpmVYgLFnvL-LuB7jSgr-V&RIm#jS5gs!5iZ-j@8?j{QUb)0-u1;V94jkhn
zr*jsr!}c4VAnZ8<_q5v}tl|7LUp!;6B7Ej<{THU0Z0(SdllPRvx5+vzE!-=TdtJgN
zVJ=K)JrZJ&Rl7NOm1wgqI3V!xO$jv4>fEyH(}&ftKilm~8Q6sA#cMva*Lu)|RxfyB
zbGhb}ZWe+q<QE69n&ILs0ITK~+jh&~KG}k9i?4wB5FO#o`V^Lk6IqUu5FU}2vBwRq
z@h#WLQ<nn5Uxb0ag8+Kc$#?g9woVc#1rRj7Jw51qE^(Cq^1FnAe@HKJSFCd;%OJOc
zKj&2$IKt=i0i|t?&^B3Ml)>+bw5}0abX<G(xj5j?I+DnOxN<tN6lRqV5gpv|^-b?0
z0Gr8!Ry%%xIjlzZT2Mao*J?ly4b=MRbEu?#&i;EsfYN%8*895#q|$!g-$4-)HFIR&
z0RIh%9N522O{w<$oh0joV!v4kV(c?jZ+DTHPRzl<%>qNCs^aR)jYsE`c0`7#g$})B
z%;Y8|b|Rsre&E_fFoA&)LbSOTNFS7Ti{8a<{{66J@oq*Y>q8t*_><hEN3QjuZlA&%
zHOPM0X!usgY5+goxxZw~iN2vdFM*cxr+#*X_G{Peg+9l;oOk!`+KN0~$W(CnkHk<)
zc!IQK0Y7wZ>TMWx$+|z4b4S7Zp*kbc^?~OD$9`@Qm;PwJ9`?FK^YhBn|E;}!YEII-
z|HCT#|4_%Q{`c~aMDeX}ahMJ1=OXaS**hCtR^zU`)S^gVcS=6{X+qnUKp!4mo^1bT
z?J<L!_P-770Uu4M+75j*9dlKK(c5NklX8n71o7=m4aexW%Cunu`&(lS<>JtjI1?`3
zire)};aa3}q3JDmlWvVq@G+BwM6Oxtq}dv-xz&ilEZw4T(&D$mn0nN_hHH6v((*Xh
zs-3%K6@Bi?r0(;bmsYnYZN|8^PbO`rxOVR+?Y?sDe{<h0jlJWt{Ni`nXDv?O+Jhu}
zIi6w{!zcZnG}?`a(fBbDQ;vtZ2&%&ANm(jYL9tqcZc!5WQ{JoiE{VWNd@Y!-z)J;s
zW+xkmF+NR6rqiJ`y6f$w*baa&e!P>Hwo%I_qetMCjB}jh+D?ex6>i<D)RQNDVjRq}
z6oy10c^1I<4qD)Z_Q+!IwR~g|;E@8QnlBGL&hUs6I=(j=z%gBr@vcQ9^0^hJoP9a&
zMDmQF=47PvS*1tYXjhQ}?;`MIMmW1N2qv+HN1@K8>D0soR&TA_M}=={i<wWHPWD`7
zJC|TR2{jBqLB2$XHVK35?gJYQUF8{{-4(X8_g&MN4s1d6&0;W@;f92wX4XI}nKbGl
zMmik}(Fd$S58y{okfjl~5e7C4SFo5dcGG|#M@zAD(p!9I1tc4xrH3-2@Fc;fGF>Bd
zWg8fzse1V>#S4!E7bgTPlR{P^{fiXDWfXQRocF1=s9z^#m)%jXm9xfHuNkaiE4Iw0
zbFG}h<qBI6=As^SSi|9Vtt}+I$-Elb(Fmbp!>Bd_<By7aL4&rAr?liOkF02@OzE8s
zMX?n%EhQF6W0SVUYY{h&{bJB^RnE+;NHEJdQM1Vt+$!bkLTwpadn1)Jfp?n<)BVQl
zM^>RPoBQ|polH7T%fQ+?@y1RZ99*0Ed2ROLtkt(4I3%>*p^5YRi+}&(TiP<Vr=E(;
zj_&APS6<|tyyx}q7l`y3I76(|kNZ*&CY9nCW-Ng*TQSzN5<Sf)C?Mc71px%|B&GOd
zC4M30{qvJvl~Abc8NPQcjIKYf6wr@!bAmFI8p(YDAtbjoOqA`HD?Ho)Glin)W`xgD
zB|*VIgd1Li7;q**^h{5Jeq^|vj$;F+$+2>mDSR@++(v28F`dMwqrW%lo&oS)dfE^U
z?1q>oD~+`?=cEuxj9?4D0y+208abeInzl8ht&5~VT(t(*;;msVd=ow3be2ywe7JFq
z3SdLbd<DqyIH+7<8VBIh+Sq!CD2)y+qMOke)j6xM-xa-j;tj8TcfwP>T-jVRh#!O)
zHkO2ua!j@Fb{tPdvlk=Wm4s1+^CfFck2O@LpKt+!^5~s6Z@P~03%)<cYuObHI+~;>
zv?@!O;ipZ8Q?I-aNQdZAn}j%}Vdd%5gM6^kMe@6(^(!0uUFgy69H}{N>Yl^BeE_Le
z7_i<GNJ@k7(Y-i^xn7A+rK3xo_k5k#Ipgg2MdixAwRg|-W;Wdtr}BGjMsiVJSa_F8
zQ&IUUvJ9X~RXXazg9UX0Qnsq$7o(TC7V&KD;a(-RQRp}=Fh)k0`7*5v7{jVK>u{3+
zh#ut$9VJ4o0tfNoLUNH(FX48ft6suK2oR`a9n+Q0wEF%I*gfVd7TEKl&P1V!EXRCS
z;ON_;mnUuZ2EkbfnWJ)TP&q+_E}g~uwMuHPie3bz#zDz0jPgBnYZ}v8##}$NhIbAi
z=jTQMQ2a;n;&>*tF5Ep1`piW2VgYDYWI>R<C-_308<?&sLc8qpjlZETJON3si$F53
zd^NS|4R>V=?Lk44uL()3H180Q>zFRHjJ$rxvqGv9)zgvAxUx1}NcfyL0o6GwHd5Q%
zLr*dsiiGce>wie$?1upLnZTZ>(wC5yMXvw`)4^9r9!-hl2__DzTzr|9buTy0J^pry
zaia$6G|n)CzlC=wDLnm$t+J*4%Va6;efA8W3$x+~$EI&##u-$xaO|A&v_EJS4z;Kg
z*klV|9~3mTNBUKrnfY99;m&kU@g(8qg}2aeJYiV6LtS&B@1LLy#~ER(RJPp=2c9zE
z#|G@%b?Fl--=#_>HbGf_%as@wH_D`82b^bbbJ_&npr{l-nDrmirOps81Kg3YQz)2A
zz82iyp=BrSjfeibt;&Iy;{JWY0~zMtIK*-cqm8QEv??9#8B^3?ZB;rE9=+nSK5~yr
zH*ZwYzN_4NR9PnhFz~FUp_uqb<pjdPY=$c~tV{z<$US^VO?Q~-ocFzwmIlpZM6hFS
zwoKewRwwj-9EXNLy^sU?{2MPYjM``dK2uT7K=sdh#OFPyTj?=A-aEmJ-=;Du#e#}(
z=Z~iCwn}H;Vz=<cv<U$-`*RpxOe2-7WkD=Uzj%D_bky;W75vlNs7k(LWg9r-u7-My
zR(L#0Hq&}Wvgqa$KF)7_^jnm)NiVC?PLCd@`)ZX@F3x0jf9QjF!g(b$8#Kg$p5Wov
z&2QYXVW(~gX=*6sB?3+m=;Chn`WEY+;>wUzLYVzGszPx^uL-F;1};>(*bFR@-Y}#+
zCjQLx0+|)-CtN3(8Qou<pE+z`)2;|zEC!+0%fIbV55lJvR9}QM2Ie(%KQ)L+OMBdb
z8lWVXV#Bs=oN@M;6*y>_u7PxeX<jN*L3USJ^OVFvr873{N+$m;a==B;(Dt<?w-7yC
zMnge?bv)E6Szy%&W&LT7tjsM_tl@zoV&$qmHbO0A+Nuq(e+J-LHRc^!B72ns2=f@4
zy6z6Y`&#KfGqe-I&|lV>|DWYEC1tMj{`(s)1y6(igW~C+VFA%e&M?a_rDdxY6&h98
zF!k7ND+ttT{G_gZp&rbw^bcm5>*3wFC`6GW`5AN5I))u`zs*cJNQaW;O8q9(b~?{)
zaEXsZPp(GglmM2a)JT4eS26?iT;bISwa*los|EITm*0GbTeayC+jk9V;YLNvSCs&^
z9V-17oABlqF|)W^50(!9m!MZ$i~X!dM{FyV#5zFmboAEFG}t{lk;kx`70&BWS{48n
zDF{5WWbaGCJZzYa)_kCMVnELdM{aZd?iyA~v2tg&$)CeX0=JZ}R@qA8G{Yeqh`)q@
z;{?GGs^?}moC-b}=t0>YDx#j+&05h`9ii0-CFN0eTH(A=@s^iL;>%KVQ20y6(9Lgp
zeH5<J<FH8`K;y)B!(?8?bBH@>!b+^Pp7tiC48ot$6JJ3i<P0hZo7eKtAXAVIQ56h?
zdm&XxQUA3J6z@SV$2TnA)p*iqGYBKmr4+t>PlYLOo|R21V59G<pa$KF;EQ_io2s|>
z2Hc%*Kf(Mzd+!<6^uBEir$ItZ2qA=?K&a9ML25!1klt0m(2J<_CSXGEgd!ac9Xl#2
zDq=zh5l|2iTj)hpq$oDHS!?gL?>_gQ^W62}-Vg8loX>nBbNuHVbIkFZQ>7%v&_B@l
zBoa(dRe(gezMsam0hH$?<9{9F6a|3Xi{QH;rE9==H<l7P4BYm`nv5GN0#1x~731m}
znr;M*8woS(Aj3~ZLfN4Zc)SmN?ivGrm6*9+e&rwo7&0gQxNi={kb!gyLoQ3saPxH>
zlO6bQwpv<g;0XIJt9U(xV9B*7jrane?zc$-gv_B(r#h@RKqeH<twON3>f)OIDdRw<
z1>QJ7WyqwHg>EtY07mAbKuK|WKyLCJYWGT%5g(S&pngCyoZhhukOYN?E&=#3zn_aF
zBGv%`PESFi#AbqmWUvX#AT?%82gVAYdeAQY4bXj%XfA5Rp+<(pQu6E9!rHs|AgfBZ
z2{lYJDX-*5E&8BP%9W!Gk2iGb)^8ju()eMnyCEi?8N@vg0-n2Dl1|1GiMBRIq&{-|
zh2%>$ekwhTIg?;zPnnwe$m|8ibz`EmFc}-!gHk*~i?I|?)#b|#!_ba!(R<_*9-*pD
z8_p>-zV3WBwjq`Z=+6M{v&Z@#w-G@lFa!q}VjZvKO4NiyWI*PWN1-iB(_Q>>-xN}_
zy+2UIRE?~PI|a@cDKOXC-ZDBC1ijvaRP=x{Dyi@UqEG`xT-0c%JI$}`s>(MIzT`c~
zTpia+IEZ^x07|_qD705YOXH$up6At>eJHS!e^EEXo#$LPQv$5faYpS5XptS9yl-Br
z5qBHUCR>y2p<w~!RCaHiS$W=_fmHG2w8$>sG|d&$t&NWgm#l5*^C~-@Yx2DScEi&r
zw$y5@#Z^(?xw3(*s@~0I$S`XhpnCNwxyPG_Pp6(j<#Fv}7woUHfh=G?fjgj7Y|r?4
zC13Hw6|-R4(c*oK)<xee1V1NUjldVJknUI{B%Ca~`<WtfqP@wS777_})rIZZ!@T9E
z8zHiWG=|@S-a$xp>T|Udn_cdV?yN_Bc<!+$+=z}{2TilCG_1OF?=9A0FXfXJtkSx0
z$^p*qWWZs3hy2ORy(W0=OUh-}0}WLwhxKsP+F!V};$NwUI3%yz;Jnq@XS88F?8@y7
zJ}(&#T*`QC?PA{Gaf}ibzQ^H3u}|Pjee}yjw6F(ht;g4ka&|B5MSCQu^>XEJ^p@%=
zlamGA^IJ@sL|~SHJePE#Cc%o>!)z*zl0^D#TlBOS`otANh{oOU;pb@2mU5LR+{fFy
z%N*Oe_rZdmBn(Hgaj1Q7)}T!?9cG;>B!j6C1^M2FcTz1N$=LSPvJK?{a*BEGF`q*v
z>ZI9xlDWlps$(e51P8MWYZ<n>;{=wPl4O{clbjAivJuu!S<+>eMFh^1xounM<AJlQ
z6zxDEvvSF&qHLVX7rZSG7OU@SpkcOkq-^W>!Kf0w{9UDMw+>Y(fiW(`mh1MQMH`TY
z%NOa~juqkV(i2XJ*{WjjqqF=TA4@I^I(H)O-+pQ(eHm<l^P<qsc&tiujpt9Bl<WCF
zBC{K(GVsrff*&c}FH*<iO1v5nf@URh*g2%vTsaR&IW&wdZzW%DvsCnB!(!<uzI}h5
zCX3jZA5fsaXc@8cd)Qm*&^}D-wB7X!d$PB8fCJ>Gvg*ZJO{(2nrh)RcD>w7keTF`<
zLZct8n8Xrq+Q$RcrgNVeh<t2&=~?yho_$eapPrm*ZLRfMcW*y;xVdz>jpXb+55aa8
z1j@VO?|_l5EkUZ?Jv2C<KOnW-4gIzKQ{5`p^phXE#>-y|FfC~tBGt=1E0wAZc(91p
z+kZY@n~5vO+coiZ`j%^|I+WO-B=CJpJu2ULwZzlli}B{*>xrXK!l4IF821I{Z4;*x
zGc|aZlm~uDouVi8ygUc7bLf+Y!XO*gv9m8-HA;gmTSbQwx>K8xWbZ<2mt*^-0$msQ
z4`9X}c)6V@T!w9psE$m?{Q+h+DfOtzLN=SQYI;$m*mXSI4vgI$Bf>X<h_fxCeu^m-
zq(v^lpKF4`?z1`Mnsic(Hiidwt2MoF!K+<ukS(6T>E%?LY@3B(lOr8Qo?h3MsLvTN
z_g6ppW)Au8r)Q5kA;lh+!i_5LQ3WxQA237Eg_+&oCdsTNbzR6y$Lyc~+G?`do<r&e
z&WtD5K4Q}h<a5;pDTVMsZ#16b5gy9S7+5-FERHP9a$1nIh1?gmXM&yO9F0SXU|v-+
z@;(j(!i17_w?P(Z#@(}(+YNHotKb`SQz=zC!1bXz&`dPHjNZ1-IZMUz`soyVPE2Ht
zJ+{zKPz8XIq!iu7Alv&?v5$})I7Fihlc1f`1H0W~_B$WXsB&sF;A=rEGB5O?JWe42
z#m1<csN1N*ospNqqV}1^H?8O)Mp#NZeU6P|WdRq@=xk_*^B=U6<$#1$1u0m9ICjZ`
zlCzv%qLM1lIk9(Pf%JPFjr^s<17c<=Ww06VWTJ+}!)mN~F-p05HkI`{cO&)b0@khi
z*r>7uHRE~7l1Bd^I9{2VVzFy<sO?rBuk~%RHFpX()H&b3gS8Gvm2pJYsIH&T*HdKC
zkJIH@)~hK3Snf(9Pwkqh4p8M_G=|_+jIo|qmj2@YL<Z9Mgw**ETw1X?&7dBG15c`Q
zx#L&zy9Rtt<x@2cd6%#mZUPgWgXaAP=-Y)Cu4ReJ-#<?qvnlnZ%aCVMpyo_)A<RsU
zXNq<B>QhPP;E2KkMwGLG%<jC3T=Ksq%^OKGxJo@$Ik|PTSQX1tCv1H9AR=A%A#e21
z1lPfeuLW$P-fixgBfg%hh*Rv~DmK20M)=mu*Lpzk4FMnz?E(mmC<MYWi}Dk0k1x1?
zmNp%ml$JzQb9G?ZMT+S1@oHIub_9?t^O~WBx3;JJK;|JkE(zZQw=kLHOb#X;m(G_3
zuVy2IuDJl=y9FG&4KNHK6i;|{wIDr`bs1=w5IQ7NSIXWkkjj<c({YYV(j7o&ZAX<a
zA(%|S?p@>#1Sz^?>7&bL4@r>1C`z+AwsKw%B{CUjZwvB!PIU23h&*??fVo}hp$UEa
z#srp~>4P4lHy~F&D4GEU`S*=M&TecfyhIc9ysKO2>9g5a2KWq0D)1;kPaut80>dN=
zUK!}JynM**+D@1{sE^HG84Hx_nKS-Yx!!d6ZIEsA_1keq;r<8d0CVkBZryeuuEA)=
zzVcp4PSp!T8j0(P=q%I(+a&_ygG4E;9X0*ID#@X#>Z>^K$koQPg-dLAwddFknO%z7
z$!~m>??gv%ypk8)P8Hv#aVG4`r9f^}d7S1|0UyyeRTXBWibE){Kx`^XW?p0HI}_@V
znW~}_)-Ba}zeY%#A)HLi(fmb+nrItA1&n}J%w)9lF6-Rj%TcZIMK009Ch*J+aO)19
zSCl~}VQEl}$ONeSN~-EF!gX%PlJ2TwAf*Igrql{EXn;Zq{R(p6<dtQ+?ly{Kr5iLY
z6J$;u#AhN>u}+H|_r7-X#Us+4TdPkVjuOBI(o(eDWw_4#Aavyrpc$gXse@xw$O}YH
zhVm>_pP4KXa!)~iJ6S4uY*QzT+H)nT;*BK1SY_BWHB|x!C!0sJJ8YP_LsH;)z)`MW
zSZ-%(EtG@Be>OK#PPp57kID@ZxXr^Fq)@dmip72T<giTXbu5>wd#XF=!%COY4+$BB
zkaD$Y>d`#w@k{8vjjWTue8h;D`@07%ltZtJKF1o_elS&Wx97^}$qBVIBBN5(vSnY+
zq3`sOrTpz>om#w)T_Js46!w#Ko>)a$`q6Q*z=vV?WMDcn2?w+#iwRgq8Q*0jv*khc
zD$kJY^Ug)|B=Z2K*PgtLTFI5g01%yQf_6B8SR!j1W<7TgW)3XSCWT%heV$x>Trz-H
zr9t0GVuEW?LpKFgiN?z0wAflf2d{wW^|^3MU3Y0z5()3k#G-Mk>;1@duNS+cf@X~K
zUHc$JDzV$2aG}V@SR9KyQ_K9?Ea<}E5C;VHG130B%MfD-`*p#4P{A%5!(;&zPMbT9
zK<CR4TB+!^F;qT4KHSpPx6y`|qFIu{ZbNi&V4ri7fhU21Fb3M4O~4z6@n)RAz5MA+
z3f!_)JCjUWVSbi@$$vV^-@3utq{;Ww?8ZYWWJs%E7yY^@nZtmn>tBmvZAL?xN9qs~
z2{(JKOdvzpqiYR<Oj#f|5q;Wg<aQmWsy9)xHh8<m{hq(EI*GrPDtK`PO;!=igNxj;
z7vWz8Ws=Z@TAq!09+ntv)uOuqK(WMNZ!aWoEx(4>(eimT1PCmlq2=~#%Z+fTauS{!
zk8-D={fPpWv%JZ+na4>y?zQ|_FM%}#DuHReO-IQvrtCl<_CA5hTl_FDq$PuQvw_ow
zf|4`?VQ>Q6v#h&qU?h{v3?~&Z8)=mB<plsOM|3wQ@LS>FS3u_4wF3UNytY6@<pE#T
zJdgZBz_NDHVL?O2EBTGWm<=7_1jPExqI7DxAz46{V|3z6B(E1r8OYJc0osHM*mwzO
zFknl`kRkGhiGutuCJIo5cK1ScVC~V3JY6uUE^mH2FW&66>WMG`0uH7i=S!&N@1i5Y
z&)`P2q9=&llc6=o$$Ud<0_L?GR&xp_VQ4oXDtw>dPRbP2nMK035XvD3&yWOMhyp{m
zMDvh{^d&HYz-tM_dTk=i<i^@aXy;mvq|@5UB&cvL8VMO`VxqKh+#MSdOGXI0S_Ru#
z{xQP6hiUxoM8(f=klYyoZwmSvlK(b6S8^7`U5j!~#m<mXLtz5>`FI2XVRDQ22$2K1
z2=b=GgBftD8qCNGH9?5HMisTi@n&bhxml}HN{AvTGi}z!L=wv}094qPMlxZynGk~y
zKv6Qdya0&3JVC7ki;{slbi8s9dmD`tivr)^lQtq7Nsu$!XwXh0A1nc6=ah+|v9*z5
zNCJp;_Q;^*yA_InA-}QNp93LjY*$FEw{pPhxuTYSAb#5|p^Z~R<8kcvVSYN~3YI&Q
zwWQL~gtdAXLpQgt1E-h3y67A)o`!2<ffwmFv?DF~hJXqaKsyb^)KAFG6qXy8y^X}>
zPXgw)SXy_POgTM4lQ?c;AtrODu}q+-v#K`9R)S#d++h8^!~y6Ftj2Pwcgd3me0T}a
zD|AS;qqhRe#V2Y(xrF^Tfb;lEdBhUJ-4FRI&t#^}vB1eXNA(<@@aZDWC?G0BQPcL-
zgmD4Mik}J0H3u0S@X-)($r2br(_n4PD#Z*tqc*(dHn1ehxcsis)JHC-apLQj9`7%l
zcHuU2vC@{`=Q1<(?frDuWX1X9j!$2DgdMN^$$-nAJ5ucav#4B>$?i+jg(#xfS7~+`
zj4#YPONL~d45pHw*s!+8M|-MFdjEV$RrqRR0N`Z3&vBr!O^}z8nR`qDe;*hBfKvZc
z(KV_7$J5cLNrB#p0;ln0PEko@f=fV}EoApIzXAo#S^`eH8F&dDT<;RxTpH|C3eIOD
z6Nvn8o3h6MnO7zQb%{!<y-)PeA)}N2hJ@2orKhLRr{AN`%$I6w)1fpPyNS!0pi(ev
z;pim6;me`3;24qjlu!mG^gSaK9wWj@0k%1ZN(hEaxrWP@g&z<+J;Mln4UBkCjCf56
zy|Z77kfb*#mPH<&inJAsa&!%N?<LNAKguIU9DU!`xh(qBRP<TFn24Cuyk#+7uF;R3
zVp3dVGs<Ff$|BF*k6Fe=bJf}!j>KLPjIVc%Z~o>{SQc~PTTD$^{Qa_XkEYH&iHW&h
z7J92JPM2_wA(%Msnm8qx*c+2jc0cZwYtnLA(g(qqw`EbYQwbl-&i|Y`zb|;^OIgCa
zAeptv6po>YIFWb0CGbyEBrwTR(^RzfIqB(S6->&(T@$(X1QE9sLrki%Hsx?R*>pP9
z7L&GGmikRA?ZkB2$=G<;=@hT>^i$L6)~@Mi-7;dzGjLk01J#)+Zke@TGcu+#3ouzi
z^=+BO<ylqJS<<JnF1cklmuHX5WM9SP+;PjXXo$L?b$-h=uDcd-h@5tRI(HP4x9=ss
z;Fb5fJnvO3YZnVr5)eB+o&UK#%Mc*+wY=bGY(WN)$6v4jT0zZ=1s}qKc#jnd#6gf1
zkhONI)Ul$I?O;V(k;*HO`uCz|f<>~giVY8^YBIqZ<PuF9*ydG{^)WD^;=+knX~v{<
zk7K0)56EB;0Qa4xz5@0EiU$DS0ZIUI006cR*pI`Qw_+LRVf+eCyS2658N7nR)q$a2
zMmz$;1K@8r=5_PM8D1y4X5T|8D97U_Efk}&P_frxAxG{=wTB)x3)HS~ShVC3WDcCu
zy4iB1Zi_x>ELn>ix+rkoU`2gm<$0Y}-in@3-GPZ@!xUcqHNLBQGS&~`f9u#Oyo}x&
zkaQku=pH$bRxDo`(n=XkBg~Rh4hWvomXfxuBM^bcnS8QFyNz<rQqQ|AMrHPvK?NdM
z9+XupJ?8X@93`cvH3w`hj*n#R{Q`p7)6)1F8FkU}H{S+#o9UGQ$}k!b&?`Vb2%E2C
zq;d#Hf_Zhcm5<%AI&`9Zj0{C6o-az-e^8g48kr_6-qLq%;_mnjDKl-tY*(*@>G{^c
zG3Jge+tW#p3lm;lm!pys(Cq;6BsVhsBusqw+vM2_Kdm<rob7;~@B+mn?+6I9OyQ_h
zkFtt$vKO!r%$d|>b~H_2&?ECgUavT%J4)uAfRPn}$lg@LK7HQ#R`aV+JtlCTv(9>h
z0wrc^FQl5)?G|M7x?zbyi1gU8%;XDlBp0^5Eq715rKLvd%H@FitjN<%ORjrB4C#pf
zvBR=XdmJtkH4(D|{3n(@w#jzpy?&_ZD!w1m!DogXOBzaSg!B1N9R9IlBw=OBtxii<
zP*8n}Eu}U&g#Tc`_(GV$S4HTGKZ2n+Z0edNR}{7EM#pjbDX17VRH3$AePS$Wpomm<
zTUOvIqH4q}=M(|(KLNB4*#ZIqKo)>lcw%AdU&#9JKm1?#NlaLuCki0O`gKhK`yAVZ
zRvIH21QmB@8K=545K@-a=C|s4bJ)eaw`pPZ{rQ5#c<%3EzJqy^)(%z=9Hh-kS&vf_
zT2y_FDtP!^I)o7a9Ug$<|3zT_&+xFaC&#aUgoiD-g=8k)9)ozVp9|xCjpW@o2&9ck
zi}pmrUuUJll;0Hb32S(gr9QvyDC6@O0n5U(Aj!hwkwF{>m!1}x*<JA!8eg`GvpN$z
z!OCA9b?QOtt5k<>%TSxzJ?;R={EKwuyW)OxQBrO#_KWiN55od<+fL*~4g?DDPBxpK
zmsI-6yyjMUD$D_pGbK0nK=|;XG~IjaFR#TFu<y+jeersj61Vp@=hbz;yCD*S`53`4
zn<s^hrOy-(Y6dc*Pv++jz1#-Z-9GU_`sn?edT}ZgF1Ywe))-tT3wL6q<8Z5=2Q&%8
z=asUvCenKHGeWYK&Wlzgqa;*36Eb-59fA||i~1Z_J{!iuVgHS`|3_&1?_}`*rJD2K
zS>penS>lhlV*ldK|18cDNCo%yP$nY-Vyx)K{;9?^M?l4UJc<A|$wZcUReihR(HkwN
zG;~gYG2fqplQaQq72pSR@UHiMl>?G9xH&MfnS@(Qrq!Pp!XksHDI5Wht>|{>+;po-
zt%AvkW3!}mbk#=C!LUKk`;xG1f72^%^$czd$?B<AF1RhBKg3-#e%r&w1NIQD$MCjz
zd@k~M>v(^EAMkGCZy7&%ObROE?Zd^VTKOUdBTEX;7OrYuRt8JJEX%_`Z~0Gs-&lRE
z5r4h6TG7Lw{3V?l5D?k67_qcGl0Q?pFG;HO0`f$Eo5R~R-{ehY3%WJ)_4TB58kp_)
z`hHFf&G-~2yUzOC{BzAv<^ELp@c@<b+X>&&#l{OC%baVZ_-zpJd%JgR4Sr)XNfeuF
zWp8}>B6o=B`;e4NDs69y;py!Ygp%mNsOICb^J*-yA17*eF(vVCa}_LgV>}O>u~0w4
zA%xK2%Txl%Vc3q?b=#`rthx)-mGBy<@Is>8G@HS8xRt0Zv&c#uC-<QKymhwu7@GoT
z8X3re>6ts7^sJuWQAMClIw+_T?N$Z7-rsmW*ukus$YsJm;u6fRP*C~Mq&<MhI{@NV
z&pouZqF$s;m#M*rAQ&(a-{94ziu^GOJLq@BilLYriFmoGE<PBFk7SNrl%Qgc2SeLl
z%qVc&O26{qMn}3Zh=X1<_V;+Q9ScR0|3cBP<ysme1!^egJ`g%fpunW!?b;~?9WfZS
z<frYoUcr!HX~_mT3s2p=&og&lx4e)t&y?g*$W=9e*Ae$Q)Vn9nai%{*jjO0F?x2rZ
z^|R1OOl*qrSglUpr|NH3s{~0KpOI@q&I&L1#5_j^6p&XY>bHuN1<dD(?AIj%XY_RM
zt{tb;_(sb8^fDg2VRrUm#|g``$9Tel_0B&x2B7Up%P$^Z9$u?~a>(hK4m*e0TybIR
zOq}_q@^&<Z?Hwjj`&Iy>c3<;3_p9xNxC@_eyj%Zq?=9upceAg#Kjz=k_z&|xe%6j9
zzUa1fytgL$9lB^b`tFw)^2hsi-JA^1k2eIq#L)E~bYHV>YdOatQ8tx>?(FIP+-&Gg
z%CBZr`wc+knB)PLYs>f-TNIO>`_KRhB0|70JQmn?3fKgrNtATaGuq<G;`o6wc6^b!
z5mZ{Tr7rWpy%z7k)w6iAVuAaUZvV;W{)`3tKVy-K;G3g<y)ma7ie`PkcWRA$3dBRT
ztEO)FTI3469{e!Q*TB-=)MGK;r{8tt3N2sHB_I~kL~kY7*OKd(tgE%6(AgV|##H&8
zIgdG2lS=DqbktX`wKhwGb5(d$Vhrl)B#%Cyzd8LLr$H++Jy$U&GGIJK2$4Y3;2g@k
z?{(F)*D_jqCPmQAT~cuLop$h7=8#y(<e4sT)Tf>9=Ii2y2|FMWY4>u!<1lC1_xZ2V
zN2MZu80CmryB(NH=0LygUd{nPI17KI^<m4;*mMW+xvw>!aR9*)w2c(q$yk@CY!`lt
z#AHyQ9LKz&I~R}s2-!UPdP}d&&NRXO>g0i$&JREaKIzLL+y;S>v+<?mrC%kHW0#R{
zFvOY)a&&D-iC6>0?+YZN7O=U7YwfHZx8K@bol>WG+{U1=*ynkMRbPrn4Zf2%#WOd(
z0uXG0+QxZ@hNiu9)xr^eJjWJsP<s$ebk-CE6(s>62N?k_UPqs2ltH)$eC?nT$ID7`
zm4%$#9Y`~HTbxMX*dozw5?^2wa^v!Nxkv(btb*<C7?*nNQkIokoS76m1pZtI1QJ0B
zGuSiGS6aaMRK!ZfA0KW*k;CyIXg+TV+I&BCgTgLM9V0f>=U-tESe)Yj+`XRu_oV-O
z>rcx6XVSN$(Nhrm2?W~FcaL&D)4e(}d5%Fc_~16b{M6<jMSs)?H%Z6#bf*Z(nGX=`
zz@~9qOQ$=^@AyE<G<f{6$earWT;d@v!w<GRY(mA^ytP>_SKS16JU*}0X?f(LxW%uk
zU}_gGVQ+vi{Uc}9tcG+xU+L(q3D#I6FqoM={^4~Tvox{##71V3lwE#ii%{+LleveN
zzn2`Rg0vzQ9u{7$i~9Vc$p(1jcYkfTR@9g6FCurMZ_YOrCT1&Hs~T6RH?Do;8n689
zGf<@eu)&&21Q~pZ{+9H6=Q3%?4=BC-c<10clh5Dr!j0<dub<S3r7o@zs<CXJCiLea
zVllg4SD!us!#iuitH~S)QChKRHW2bXD$0YzH+`fUSMDyEtN-IoxP|QLT#`qG!K)+0
z)9dSZ;D*1p>%9!e5I9nVo!>XOgSc;KuDYU3F?Y^Lt3!9@`N6M6P$-5rpRcpFJbkwI
z`+|cxRQ}}@dGxLM0yNLGucUbT)sY6`A%T?f3tOa$M$%UvjYbo`%-h`RzNJAjYB#mV
z7R!)vtmWyUX04R!@J{&vs95IWVhQNj7=?|zw;Di;(`j2S;RvG2UW`3XFuEv=QCMv#
z;oJstlt%{z{;jO>UpAESf2Navifeyjg_!aOR$BhV3YX=8B>W8vD~jF;8P{_lJYXrK
zYK%>N?;lv%-o@cfctz#xVyRx<y>Z%VBj+;i%)@vjB#p?#ma<zXe9?B0GDq3bxLLP{
zitXf)yXU@b_dfC?1&!xvGooezo1}DT$L{PSe{R=GHm5V6-V8)Yzq%}lM1(EbzJdy?
znoRrZ2(Ig0^5am~c91T*mo%6iN+|**Pj%_QW4;SHfKUPJ({G=;j#fWB)5zN+ZS_rl
zj*7|`Jy<q!aq`SU3(=_c$El?$$iYl<mo!o<X|S^7d3g8jH<S8WvNCeB<g!!0V)@7b
zN*C$9V12}_0qdmJS5GM3GyO(f2V--2-0`HX>#xY<jqkOt`yEL?e~K^Mf1mJM=<AH3
z5DHIA5KqWB7RypRjFN$s%@QfRw_~sZNM<v;)*dVcm&k7Ut>C~BJHlK3TiWyHpkKF^
z-ctlo+dwuLib}A948d?V_J_xc%%uu<o!oqY<_#%_XBY6HCc?hOdRulu(l##9&nZQc
zVF0#+bgWcUd2enOx0<~hl|gXi8ze$RdL96)!~297Fg$s}zeLP!teGtdq#(y3MrD<I
z$-51}+Qew4TrIvWa;4$4L-6Iszm+=D|C37pXLX_eqtcJjyn1d&e^&1VH;2`CSn!Ek
znwW=~XyjpD-<@xFc-KhX$0JGxh{?}51?r!DC=a`68>%c7xx4W>2a+m;r-n&~l;aTS
z#2@P`cWOE;jSMI5q%leCnEtu9-DL%pJjJ?koj-*lTL>`N-G!(9$`xwna$`-6I-?4c
z=OsLcx2dy4nB~uPr3ZXqlaa>>lun4EYDxx|cpvR>lgc}klKUAq!qw>0@2}#r_Kc}s
zX3eo{Ym42@H}2i(&^dai=9&&M9bNb$uQ>7M>-MnDP~%BA0Zo$fzT)`-qQA9z;(Awt
ze1vc0nY)i1_xHQqH;h31?c0}6(8)x$&ri=?+`IY%n<4agqIhbIqOluSl%-V;{kGUV
zlJq;V-!WpF=xay$A<zI!cnHLx{J=)BB%%Z!b15i^wS*&y&t}0Z4d|_1NBL>Ldooi&
zxCF@4wapKQieB73nY}Yu-X%E%NvY4;Q_{Ya=_yU31KF+3XToQDwH@+VbXPD}-^QZB
z#^K{cqjSgMmc>-<75u1PK+|fm-exS4$bQV`)hzpEtj}^yEa*-ymMaolR4Nfj?q*L#
z{!v|oA5y?LJ^YfnSl~th8>_?wHI_N7HP=IUFnsouqA_A)y_sclaCOs_HDer=8GPk$
zfu;E0a|g$Nq=l&nxH7fvBdfV!DtCgR`3z_>pOo@|(-)6NxgQ<8*LT0Lc2DwmKdZX@
zWzK>fY}-*%Zn4x6W2myH_npMd<JRTss}^c&>V-(8|2|siByZ7Vqc&H~sn(qW;nK#q
zTOK^spTTa3MHDViG@zmG`P;ABmX1->s7csXOA+03Uxpt%#8E;#@?!RH5#q_Ndgs5~
z=$+4iqtXgrw^qLW@i_&`891?X^s5=CK)~-|HU(_fnaR8p@+d3n`b7gHnd92!_!$Ap
z#mbs@nwf+Xoe487@>Bk!@2>-|r@Ve^nNV$TZs+z?PXDKOE$?q=aqTH$K*alrQ_A0Q
zJs0hy6rgow0yb}rzn}WqCUBTaGX#OTRk82A1bMVXl)tXb4}f65j(~-am;l}+jOV$I
zu^B{;7aY1{qHZBOXcqxHHTyikiwGlxTO0m<6Jcve<#V8?LV}~}pb{8FhU!>g{WFcB
z$Z!Y<-04p`&Viu<1^wQPk-Rh}Cs0mUVkD5oM_lY6rokwuBf?G<PEd|9bH`987e8vM
z!QjDys?d?~5nW{J<)x4aM9T2Rgs)k{%E&k6PB5vER$^^Bs|wZSoEalRlk<ZpY+_cH
zmm3SB383T7iQ96G6~QyC^Ys^k*N9D=C=kcBGnK)As{qyhCs_H5wz66X^nzWzSbGfS
zy~ptG$c#7?EN!+x>Xz)w`DoR7s_df=G*c2@WOewg_>o*qeVtef)h1%L#@V^*sc>1V
zOXB2v{5p|UPwNdXs3*GKksD<Z7`p)`usazd>aXlqxfNs!7jlpr+ypWT?W?L4TeMvQ
zt($eDs;$S&UTeCK48P22R&vNGalHCabf@5I1|(^HG3Wl-OApWe&YUG!MPIbJ$i-=t
z-~3s;O*3c#u^G|+>DeQHc;;9B0tqci7zS@XX2c%w$i!z<=K3`{kvo$A+@Ty&^y71n
zEB6&wE2To}9r4;XwT}KUSsS{(ckk$i*SVMqrtW$40Hfnu!zyK-?W6eb&r^&%VN0yA
zU1vgjhiqy1hu_9TA|li)SB<PnIvFM8@eRqg7`H)zKrwVe+Iu#(>ev9&3)R-U*E1$;
z1?-)RvlT`TN;s+6<85`f1{~+}4vlQ(9g~%L2~sDp%j2ot<+A_|)ohdzlrLm#f!$6=
z$PXeFN%l3D4gMn~gswK0iMf4eZK%#}pt1+nSs0ZIcWg6^LnR^0)seiYzaz`HvSR!%
zvEe`PP9}?Ya+n25e}2nqO;r3tTosek;e1kNnbJ3F2BR^r{YvhiGKT)KI`JB-W|&rO
zEkz{=Im!%HA3D`pC3{wO_#)Eh*{QOFKGrqj1(JEHM?D>zwQ|g`wZOSFD3`deoc5N&
zWVM)~jA|ycuhuyOiO1-MUw&12{N!FYVS}!AX8qHx4`}&bwks|v7t@BEr@?SU_1mrH
zPc!;SJ8QmjSEuFe>&eRH+9kG^lr$WABIje2o>EQ<=o(u8oHb2HPi(#{elf?Eabjn;
zSAHWxZn8Gc(0u?<@7Z~7qR#O{`sjNxaIYWS@6Cn725)z|ruK9CN8VL}Eh~ceMJcjd
z=f2aFBuy?Q)l2y0sWg3@jqcdxz+zoNPz-?Ru_o3pZY$nE%RS?TW&J}(TGWh_K7<_^
zgSt<5k80GLgb&J%Sj``g=9F=zLavq1+Zujdm@hDV8%hC${P-w%fe6(I=hk@R4z^aO
zj*$rpE{mCE_E1&@;R*~b>;l3f2?BOGwRfFe5%zQdM3CzI(&Kf|pn!v~e43vl;c{jZ
zly6<Kz&R3mVZ3^vP1f1U#gj!%$?V6iXaj+_fgJE!3nPe#>e>oB)kvp{U7IB*RPDQs
zQJT<^59OQ1B5909bDjpqWqc$xxTUHoyT!P*k3-?ZHHi++zo#xd{`b`IA1P=zt6d3X
z-CAIcD*i|fFy1O&UJj_4Mhk=38!i0)?ujf1se2Mq27#=Dlgys%&r5#8+GjocC2)I*
zv||x-;&F$IH@D?gpaZp<T*0xS8qFg$`nsQBoSIim*pEbg?OEGegz<RjyHlw+a4H*I
z-Mm4;cHKGm7=vvUQG`vAa@SLBiQuGWLL}&ucP-KG?P9i2OX{3eje6kv+N}t)bc*+*
zyjwfWA1dG!wVB<;N6nu+4HLUK6Z|{ce2|^S(gavU-pR)&PJGhdiunjjZf*Ng`ujO?
z<q71`&7CUtMKZ;HukZU|aze=IINeag{en-Q(J9<8<&TcgRYLErnCpAF!{lErU~z=i
zP=9_A<;uI4{^;Wd?j#A&_m5NW&zonxbaQOC*kDjNHkT#HUk1OuaMWn;tum~~wp>c%
zPL{!11qRi=&cL~}W7Bm9p<d>Q>d8FAYs?IQ%<qX5i>$$*-EK!McLIa&j&}DEQ1bQK
zT$NMU4NvMZ)+<i;U>x=}RNN|%4nz<D^C^cjmtVTR?PYCqNsMb`1Z=!o<kvPciC%I#
z^0IMR@7&N9#x)@NJ3(+5l`>qLDfy5~?NI0j)s-U;!C)_O30`fG()cFV@CSC9X~&tX
z&3Ns$AZxB5+7)&&DoeM*b94EvUAu!c`EdO{``?+;4zhsrzsgd7k=10FlyD@1ht<0X
zDtU9uDkQU0kj4&>sZSodIUgN7OUmSvjWTh3mMz+6-|1FiP7i(9<y&HjBZ%~JjvF$4
z)t{r|A#tkRx#oGv!lIVrEA};Yh;0*dBBw!=rMi`v{mzQ%wWD7CG%CRINxUr<pk&@A
zW7D8}mv@_rV-rv!@4n>fX>3icWoEzYeYzzfoD3i9aqL%?Fo<4L|A|w3vG%gz*f}HK
z@zd3ZpRQWQoSLuQn!7_A-z%ohn$8lEITBy}mQ4LH<+j6VMHe&z$^M?hS+IC$I>J|=
z>aoxXjW5ZlEBI!~Ns`BC>(=p2EpxAIlH6N;Z0Q;F$Jq6y54D$uXd&muy7oQ3*?ERm
zY>N{}?*l9!_g_N&nm(8VgkcH9Q_jGQOB9rzeSyJJ^$QN!BcY|3*jY^(1c==a0Y30$
zdme818`1TOoVzM8Y={tzq(Ex$^~3o=gaL7i<lYw0NC+EB2AUf&Po$c^#EUzs<@Mr2
zJ`sf)p<>z_wH{ip78){L#Z3zJwx~h=6*ircto2q=ScXa`R*F?qlpQm{=WeYspnN8+
zj7uWBtFkoKY0FAm`y^J|n{%ArQlB4<T{X_^YooH`&4&V;(vt|Q&9w9%wy@$P;lERl
zrdjxq_)E6@XFb|C_(Qg=rBk4Ag<Pt|KXj0Z=}*&{ya*|@Q~T_tj_8l?YD4<@+;#mW
zjI*~lh~4Sg7*=n4|BlCP9-O~0{#e+>=heC@20!H@7c#0gb7dZvPsolnL9)#Bukg=1
zP~9vlOR~4?UedfSp%*P*emKJCb^1ol(D?c&LSnA;jb+T5>otv+n@U$Vm6?@xgVD~y
zj-TD`MRA?9uEN|t*%ZHwG&tahpX*P2n|%6;bJ&T&*n@D-U!M-Rzc@rZ+gVlCMj9_X
z;gjxhxXrR$jJMx2@y8--5&59y$M4sCmoqh`GK&Q7{^+<qu@Cy%T5GG}%j_1^<toT6
zg-~8whh(<a>i_)u;cbcueD_isFM4x+>iiRMR>tc%8ijo?ibOjPPTCkt=9cVXCJXDy
z+5IhYxA5;7{Ld-FUm^nYNeY6;-`xAJMnLxLa7qTBl+Cr>8y<bEDZ{<uBTGK!g{b9c
z=d>K_t>Oak<OF#&f9oo(=OMfFEv9*e@aegUV{Ofv4Hilx#Tk9l3@)T{W(j~1;B@&Y
z(NlX<I@2Xf{<hPXA5p>1RG9hODnEKE5oSH@@nLg2;Kk*`L~;6JfiRMj?O+3aq2MjG
z^JI|2-E6X>K~y1{AV(&5^9B68F-v}PNRa`F?^}Fi3V5dJ4ryz7B)G0N(Q@Xx!$$4!
z`&PEjUlr$y{7!ag-TSS;<Bp&xogW$qoevmAS0t@zxAyACEmQ1%H@*G%FktlE-J`$S
z#isYBwpWeUr-QC)<%uLF3?W)wf84{SDvYfc!?jX3x<>WCSalIl4PpJFL?OG-qlUk%
zQV7`J>puCs$n_ZeGrDo1blJV_;$gt4h51o!wn!$<4UX)g3lCzzFpwp)Zdif4eVTOc
zx4<^bOe9LBLs2YE5+otoC~B?MJ6%%T&Zg<)nDsq%qSQWo3|NYgDST$_ctL*DX>)y+
zZ0zPwGFBbvkzcMJP`s071NIVP75VMeW%h(0s{jt(v;jvb8ha(M4y|fw1WgkbE+lXS
zk^X1|XuyWT=pWQ(TKwPo1~>mVXfTrhp+)}52_@wwSp%q0^m|IxH{RDO5S+M~p0@o(
z)&NS)WqtQRa(5xr(5kv$&BwZOI-7#x81K%2^#)E3@A3vbEz{@N<F+hrF|AjQ>vC6^
z2znlOm@g7xK1)l5aNw~JmWOiUx;ux1Hr;Q$MH7bIg(%#-{3>qtc-?PVsgw-t_`u7n
zWuIos5l$bG`X3NR>0DErJ5p15?+qeMu~g>}{;QrD95yB|nm?n2Rf^Yk9!2@cEH}GF
zrT>yuB<2QvpMFN7lNg$b^G%{8owhsuu)tOG_FCol8vGD`%%hmkPd9God`Uvb;*RJi
z4ARc+$1<<H>r}syb8;v5jaRzJmrZ&8eR`>Wq8~T5`%J>m<Znw0^*qod+}N=G*Gw-!
zSWNG|aYMN8hLQUBX(=`ktW9;qV1iJ1(K+{bH^nw^y}saJl~wq#{%?1qF8?)-3$Ew(
z5!>Y|-*)Ta27BxCR=h|$O!C|bX*)Z1*qfqZ%^5i<ZXQ%1cEO{+HfjvW?mNo{Vs~d!
zO1K^5tDGQ2R(T<9LQh=qH7jYd6J=Z$%d_CaORGmM9xk{TD_|T@BWAKOq&|QOUa9TL
zoTGb2#S^;Nsb(yFp*UaF2r^Je4|J&9^I<fLB?J>&>Z8Xl8*9p3pt4s+GuN&*1;fc}
z*V-l(#-R9x$^+N`mcZ~|s+IuY|JrH%m2m!0xH;4bQh%wI0ZJTDmTD<p?RKkXuvqxL
z*HKAgig_mf_2a7hg-acA2Mjw!E%@F%t2`JMANk-8Y50;z$`bzgM7MpV#aU(jateqo
z8HrYH2T<y)S~Szv6w7B#FUTMeG<$*7KA@&RVS3GR1hF}6B-z^0RYhDw!)qbY`buP=
zIUE|gcqgDh!XWDBC+j+-prYC3bQOdN>FGOzb6sN%x5fjlm<;>g;1)@*h~=by8!U-R
zHp;vhu5xt`%Gl9QtmI9=mU~gADpJ+Xn~c8(2PAwE#;KaWXkN@2(o~K4?PdpB>%S@3
zy0_B!JtFEI!_}tq(cOp>Z=Z<pj3xzTb61`1bv^sIb2b^e-DRtnJ|N4Nc=@@h9Vivg
zKP>o6tlcx&7*|3ELd{j*BqT5T7YAEgOy_6Jt2s|N64@?zWZKxX1SXX}*u3>D{y8N}
z*P@l};K26Ee8B+VU{79#fHV=p7eezbvQT(HglM~MAacY5Nkpite}x~b{5vh!a0Ia?
z7rsSflnQ+2>S870`sz~EKIHH4I^O>+y8oUtGy~~;f0Yx#Gh^xJC9r1e1XgroWM2Ed
zkt?uIO_gMw6l7`AZE?a%Bd<AbEIy@59&C`4&VAZ*L0faPWNIbAidSd)m6YGXAcvZ*
z_(N&(Mcw)F-&qRBea9e|CL11q5|zntO}MVeBveMMPQp2i{LKNi&*fF%YYee-0#_$5
zoyLR)hP6~VMU2n!G-cjVeRU^BP1+6HC~lZIrT4zO-%{D*P6q!Ci%@)pVbrPijn&e#
zo7Ocg&t-fINqPDSL!7GA&?6G7S1v@ne|s+DWQPrhp5hI$m`}Z3(KRvy;{|VVuop48
z-~CP7mHj`)JX8UVQu=l`hwhHQay{!3$!n5ZcF$%qVU5a7EzCC<$CByb`zu;5=cj6*
z<7@|e=4|!vnapMDPvH7#UJrr2biS$W`BDAf%zC)tUC}6y1oya5mgC>5-umEuSaGgI
zxN{pWBSxr)&N^QPWB^TMsPi_Zep7W;+`e`!_JvEUNg?!_P)$m3$ApTGpQaHnxCGlV
z+*vxqQiXr1ye&TH7>me>h1hYaM@|OGstyl7Zy=oMJZujU0Vu4nL`Y6K4&E<8eo*0G
zK8$)Xy<lQP@o{osU1I0=0u$DBi_$EX8Xr{GP#PRuCy`tE_huSGESTW_qIdt4AKCX4
z-3D55-7HB-+yoo^nl+VvPkGv+CJg3*NLw~wKC${Wmi!2T@&X5_lCs$fhd)d9#|YM&
z#(u{wF<^BIv!a#HeUDNb<9{fc-)?$Vhl%P$-6~nNYSzko_^UsAjmW{#WjR2)u;iF~
zs4;x!_!yw<=pCclLOR)Gyz<!ln#hWqSBbEp;ods|wr@2w5T7neU-^2;mA!3!C+A3B
zl|fPtLT==dV8cl`*TBb!C0VXAo#Gbr>0z~xHWW|3*7@aJFa-=#-}dFXyET){)v}rc
zRhpLOhbqT1^A4?@>SsGltDPKuZxB6(U2LZ(w47bB8V~u3oXopq7#)LDgk@`;8d(nM
z77q-|DAhUNBxl!?e)sOX`c{ERq6l0xlnl^!pNA{UM=n<ecuK40sZ^V&52}6HNEr-v
zy*njBX5#D$41c|;w>A7NH*VrBru>ygu+$Gdsy-eX!K2YHN1;P`_wEZ=Nr>7J5J9nD
zKp@0=-#c&Z$Iv1Z6zh#8n|ej>E8P>$eh5>hb`+ndCZ)c#)atPjYo<ZF>|g0-V6g;B
zVTq2_k(0-A6_M?ir8%TbRJ&jzkcUJF1^E!jp;EX?gtEpNEo}K_Lvr<C#zL_XR}jGn
zS|vHdnuI3Ut+v#oP1Y_q{H+#InuQU`e@)9#EC1$PptCTdAZl;&Pi<j$q*90jE+zSk
zHQ|8A38~yWb^ps-4Q*bdYz^~p6I99PrLZ2Bws5aNJs`f^9P)>fa6TNSbH|_63&j0M
z9dz=2R;5?}warYRZmd>9u1+s|Le`EV(aEdyy+pCU!M~K#mliGQ(&BfA@#g-`=T9Db
z9hg&kswpF#e6mLPWiYzIwKiICIq!tCH}jT#giYS}cKH*7XO{*1e*n8!h`=hgap*|7
z_c!nPslq5vmE4;K%**Abub;XT&gRKdy^w}UUtMr^)tYCgtZ!%e%r)N>zp?1``NyQ*
zk4wc**x~Ls)|w06HnVl89o*yC)QyD;sgJGQ|2)ITISk!*5iVf}1`oXQrU$$2w0XK_
z#*qQ|Z`;P!a1>d()IT?>jG4Sf^%)|cy46%+!~S)`%?^dBJt8bWEaPRmIXpg>qx^N7
zC;4++C=iTj2}D5k6;p-_dVk3+6m;qFx#t<Bjr~zAn7+j#1ffNkuwH6|9X^u8C_Nq>
z#0qu-Y4L(};kGSQIFRaBDV+J;_HT6^8vh}-{}?~~)&8@b5N6Xa|D=`&J5R|TNbbtS
z>YLD|N4*~vW2{-tz8bzKYilWJLi?;=>UjzGP6#@}zpwm>WZ=N%Ev8AFdSYK&)}5B;
z9{P!$SLIpSWSx!arqz{5&#~HLT;hv5#lfjpy-bayk47{)U$c=4xuD~GQMooWC%^IN
z&gtXjA?M?Jf5zN!x)a#_Nk62lb?$D$TbU6Bt>CGfaZ$=H!4cu^1G%4*okPkaoJZqh
zaErRJ8jE)+AEHgJKiD3PCWt*To4NDt#j6VAXlhPd?6Y~z6i<Pb$k=ATfx4rYIzt>F
zNO(=rH2v|TZ#+_F?h>C>sd3MF(PLL_M-B8jHWzu2kgTng^q;$$9p?>Iv46ueVEkt?
z{lmr0vX%TNA{?ppi07ji=DVQbmRrKwXdIF^H_$F6#b}d$_e4e5;-k3fE01AcK6jfJ
zL1gQywQPNCFKyAir1)OQj3nzUewi59_OlB;Xe$0p$Sc6HNsn=?n`o5s{Ic*Bg~yyI
zQEimzS!BZoi3oxT;T@dfzbK3b8;=X?h58m<b&S%(tI7u{zPe_&gR~+)b=N!hb=v+!
z3D&4LE~?7^?aa<8kmdT1SC683PChvSwGqB2qH*?FAv<m7(PSW};9=?uZ4zlG^b`{B
z$*-aMOhQwdb*6-dl?*vM>0h6uA8PgfaZs0zfIJqrYC9QwGIAgBi3mdZ{rvSM=g3FL
zLQbxWr;>Dve?cLRayt)8--$PaBfP$P9IKAgd;vw^L&?yflCC_%A@f#(7ub78#QLNK
znVoxxhfY!7BXom6Wq$s(cJ#swy4ql*`XIiurF&GB7mt0Pm1VI=1WxRZkLrKlHMbVx
zfK1z@#dt}H$8m%facj&39<)|JElLAIP(_PQkr?qz0#K1gG2?~dS+t7F{oX{v@i0Fo
z@z10iW|7+HpwE+uIj$ovP+A$s9`9x3xY$GRvXs^-sN0mw@~Rb2KmbLbVtrN{%Ryi(
zE?jOi+Tu@PuD<jk<8p)97|<F{oT0FxJ1{>KuH7zTUN*jD#!_B{r)P-J$DqIYpu+aQ
z`Xv8h6cb;t`$LiY!%cAC`b9DvA#J$;_=lUIlWW=D*t`%XUy`78_MKVfmYdla0O@a1
z!3=)aBX5fYmq8N6Aqw06)-`&?3Q7YLP2+K<Vp!91VplR7Tn@8t7q#MOp-W7X+XWhd
zl&ic=gTo1mtfxg<lf&7OL?V0O!-||3m3P{Khg;_EUeS`BX|do3Z1$ghb2t9?ru|W7
z?YeU(h;>nlZt7N}?mU?=QwFzN?)4XIzOaT%g8|ueItG$IU%WX*6!Lj<z~U<XuDEhJ
zt$z4b+o`FI*`w@wpF>~S_r{aSGGd13f3Cg!S^RGO%*HfLm#+lNR%sYrE(grkcvlhk
zL2z_rFUE^<De)`pAOHk24}}|yILW#vxd~)U7^3h9bHklCMgS1Jqz<0U*~czm&h5*(
zpuWC7{!F^~P55X!NBkrv5MfX4R{F6$4mUu}bi*}pB*1HDiM<q2u>Q7s-k}N6aSo-y
zkQeg>DmuFk0k95oA0OKvQXTBgeXI>}uZIjVB*uy5ItnZ_+J)%cW4HvplZLxQjvQXr
zTlT#@USjFj%B4C0QCOipMR|*!c05g6smnH_t-$zl$AISW#_zUJG^uj6sXTg&H6Orn
z78?l%vMO}r#o)CD@ZWl1<Nha5{%Je;i@W{dVx!LfQI~_q5X6#>fA|boLYy}r$|yHB
zbS~XhkmWOIacJ!K64^_{Slp&r<ZQiLoM>^BwyMxLRcUhgrrc<?LWL<np|y#TC9o*;
ztUMw>w_MEsP}G`N%S4Uvb?=wKR1iDM#Om8l#S+<gL_(7re~c`rUlWAIw^P#w`RtOh
zt*xo6X351T<JPX7+qvPAtlE|*B3Mv!`_z{;;sO4<YxaFUxV85CDiQ{X4IgJeWVCF(
z>5aZ))L>t560g4YL*Cf<nS}gQcHyDYw<TXYvEYZ_x1<OahMw9B?9h*~(fWy&+>sx?
zrIT+bb=S%6?TJ=hgU(Fzgl<jgAA90s(NHXLMm+KB&S_Y?;USYx?z6Q5F>e$17Ve)+
zm`^hm3xm9B_N4rHJoVmnUum}-s>8iYqacTxNpUACsJ4dI7*f7rG=iCHID}n!m9c$V
znxZze&<ao<@uiTZN9-g$?FEus%2<x2PzDr=!ct%yEI$gw<grT$)tHm5?EH~uQh3)x
zj2%v@8RgiN?NZp{1*gD~;wHUer~4NiB_dmiGORSRT+{m|%SwS;Z(GJfB5;ghD1tg3
z2uYU|CPMJL$Na4Gj$<#gM#n4{o0!I$T$%W=35Y`smM!0e58NoPZ)y55+I;Pz&filP
zgIQSl*I4o2)x|$N%xo%=w+?-->5XA3dzZ+jfqDv%@~nyRts0A*j|=vN8+>&=r?(Vb
zCIaoHpO!*T_BF(XU9_$~EZbK-xFtK5=|TFm@O@+{4FNr9XWj|`J7gctxq;fHFf$;C
zzJwo6jpQS|78&ZNABN9h*u@Pnu@OohkK>n0h+bs$0sG2B`-hD-X35xy-<v@n`fM-V
zfg@k|vvu4>r9qF<zK^5LIR%`4tiLtFM&9nD@B52RqYB=u@+#?NKIr>=95{I1_U1ys
za0bx*=VnEfS>B9h^zVmnzdo9jdE#rrxw{tg`NmG{mnI?l+k^w#ppGAx_v;%osBuQ=
z3#xK8KPA_s*n_|L+z%uq|Ag^k$AV^lPo6&_O2|CiVNZL{S`o=e1FuKPG7QJ`L%US>
zTKR|Z)Q}fXH6Bx&oX%<fj)AbjN@jBn_7;5LhI=dHUMW^=E`vOR31m9oJ?#h{tqF~k
zrzbpo>s@m9{g@XZP&~j?_y|4}07>MrD7F<#ETKTS%}EW=z{G(P+XG_Gb|uDxPEGdS
z4hUbX&D{n6s?7nPK5OrAJBZp-Z2j`Z1m*73Bi=|2md=>l%BW41iDx+;wIe53WFK*v
z?N7&Jo(|`Pp^(W8qnVaunamDi*$j;TVKcaA*#&K42mT%PAm&dd^Pi>`0&6N154%Nr
z#hMB+ygCA{1(OjVX)|s<uVasj<z5GMv_JdPtX$-Nh*g7fHFcA?g&h3{D-WHW>{%)b
z7|r6Vd)X1E)_em7E<oe6xaGzxmH139tj#Vv)NW;dN_`cv<l3rZY>pEdUq4pul@mXJ
zeR+B;&!(2s-EQiGNBc3T_{!0()8p+vP>H+eqCAgNV6YQx2fj8!2Gid!itPfo-gi^j
zyf@yoZ+gB6%;8*jpFA7%5@k0Z^{XV}WaA~`)g{ZQ&5-dB9~rjb2>G#VDsk{Kt%3(z
zOIuwp56#>$hIkCzKJ`97*R262e9!XWTSAgCWNT&clI$1i)eK%SMYl}DlS#jL@zeLq
zuGpoVNA5<^fJwp$8)HdGu@+hq{BPy%^nd>z{{vP0Q_@v#{g?PA%X6fQ^(1!aRLpbl
zN72H|QNLiD%w#>O_s?F(hFu)OiD|S&THLC!u2es}^d@Mdv4ci9ZP|UfSdPe^XtvjI
zxn$Lt6QzugrQ*6%*id?z+lPy<j5VQX1P*n1hitA415F~pIrvqcbA~@1@XY;w?3Zfm
z9M{jnG%%{L(&I`QSS#trhUsL?sHfpca9xpg{G>5E@64~>A*1UOnmT>I<a1P)SDZR(
z3^PVp50DMrKsGxm{&jb~r*or*K0(dNryU-Aw?44hx8so;mzE-9K##t>Fj0CfY~*nJ
z@@nsOpGmD3@k?8kw-_SdVt%8ZtaqL?w!N9R`{V29JdJ(*_df&9e9c-GPk5u$R}#QM
z{U3~-hd<T-`~RKeOc}@C92`O_Gb7_1n~Y=cl|3U{$gwkzD0|CFsAwmfgihI&y+zqc
z#qXu}XS_e(&+l`)b@LxM*X#Mbo{#JPcwF-|JYbo5{WGAZxwlf6stwS-@USTC*}+)9
zRsqtcUldng6R%3BcwqJ{9C30mpA|rZ$zf;|&iH5Pa-k8IC~-V=#l(>@JrL?Vl~K6$
zgp7N;S0X(Vujo#HfmN=HjIAGCzIfZ3mz<KC%?(X7!uSG%SN4J$fjqtn*=QJd%BnG(
ziKOLP$TTwnLIS=3R618|4X!x${lw`4YW~_4Z1RN<f2O@;05!n(f8N#qz<F8|fR7B|
z1T~v~YcGkk)=w1KCBs<+X-ng&Ra(8hdLB%6r*W&KVa(spyw2i~9n6R8adGEjJegj6
zzgneNq{t^oDV!zP9V#0f1`)dHu3PoBgll6}W3~S}tr*4}?I74!W)Rw4C%mcBMngxZ
z`7}UV7lbr#cF7WM_-sf($`j3fo${WB?Z4OM<7)#C*11=K8Qo?&qR)QX-}+psJFVy~
z%~3x2VeB&&Nf&mo-Q#0;TPW?z;w4j1&&o@Wn#h*~blS6sA)O{STxV`eNLjJ^xnJMx
zGRYJ67n7w^*_u6<_9y)}&A$$P$~@LRmYu2QZV6j?*W>7#_G9C#weBenJH;YVh1l)o
zZ<!q1qs?}y%r**l5k#P|;qb*mC(kaMMIlN`sg#DBe96EpJ_fLuug*{|t2r@y<<kK0
z)z6>drTj*+?@1MhI}LRf6hg`2*ROE2?wGE4v^$>yee^Oh-^uG99R$jaA+-w);yb9M
z1`$KB1m*S~>ziO3dlHm|={}5s4%mcveJWIQ!Hm`!4I-y=5`AZ3lDBFUqD*CCU~mz4
z%QbvpMApE2rk^jpB$iruMfRD6$$L2GOw=iHA`|&)1(B{CVAKgF%W$?CppuGx&>q!g
zN!rSlc@%s4CmK!d-Nr|ZeZol2k~|MxK7$I-J%)GM;KV;udH<)lUkm~gbN{95acDM{
zU@2krY`d+Er5*7+a;S`}e4Po&Ea$1id*AVZZN`^gUW5B!UT4hQRwHdTlwX20wBG>y
z{+NNFnKB;x)d%w$p<h+g804<lUc4oLO>THo%*h~AC3Q`wHfuJaSS>EE;6{`4NIbW*
zVw{|Rtyw&SpuIU+TSpuOdCqzSdhX0{$=9@c`D=van|$RzMH2}~`cp9T9-jfvN6rY&
z$?nwT9=(a?u&ok5v64%502%aLZl7?)PBHxO%f{X8^kN=xz{XAI7e+I2D8==Si?Q*X
zubkZKzt0C?v*jm}_a6Mz06qS~3hCc_F43B+WJP_M7d}~kAF_Oy$Z?EbzM=zi{TUk<
z5@;<J{BFR1nO>=$I}hA<$STn`rSPqrRYrO`<X43smr{3AN#S+t4d+%kI7vf~aIo5A
zcP)5!WKz$vgtjD{?nCfQ<f+I?o^T$N-`gnqsVd57%x(|b`;E;E=+xn+e<x`D;2{h|
zI>_ulCGIkgzI4@T1_bTFsC0l|$dE(91v2DFIRBK1skbYqJr)M&e`HWzG?2h`gVo*G
z%#JWJ5roq+vC609-ybgY{GwI`cVG<sRJ`+(HMJ<<91$tji>X~H>s^^6GqH=<)Q9kS
z*{|NAHP3U0zu6E1TE!?~kLr>j;1R*zd?N!^<<Tl!Ri_O({4*u!E>JOi|Ed^<UI)OR
z1SCZKTqeZO2ug{E<Y@ZM0Tm;0S;zc-c^3`evy-TZg^M@&wJbjy&XxeCbPXBSiTX<2
zn^IMQLT;PRT{*lT2P7=6y1l-|8FpBKFfPKEt6p;Xtc+VVq!AmCiGWK98)lp3KbmJ7
zSs13!f`+|lMYqMAGRMLAt@bDTZo`!DszhbHkftKF6PZw#`&hN>5Jl_^PfV=t<oE=z
zOvr4W82_2eITY0fC%+BM7OT!qx!FP0-8ip}i(KkD78G?8ADEU>wD=&nqv10U|MZ^p
zJZJA*6o1f9A5P7v8NA}PHWb-d!MHs&dGmHxd2Fi+SZaP(_BgXe>WR%DEQVpFE8V&T
z%7ykV?Y?43C|Q~|xgtQ+1lj(`@kfMHrugYbK;2BTT!L98b!cJz(di2L9Gf_>cVlL{
z1Z<`%H?o0N6h(_bUDi`-2bw-`&Zd$68QPFubQqsFQCZ?BC*~5S)@`0fTI1(!*1!f<
zW1yXE@&ka?nT~X&Rr9M+9*YBsV*<xI;vLZ9QU^fL(DB#7Al#x@Jypw`iK^yeKvcQg
z0Z>3}z0T%l_y}i4H7|qBcey(=s~>zl;+&U_RG@t$_%P}K6Kmr>iF6<#LT=T#QEb;u
zMIBHV0T3i9MO1xrVWpDCw-Mmso7Oz;)~WM}M#B)^Yi)r4jp$kbY#$IWxP6`O!UE~;
zf{>gnmp=cQgXY=)>>*3BfVAj?2By|0PY#!?$3oz?MD%G>uk8DruY(yELz74#C(X+{
zmu<tP-_FU0HZU~>ApI`)=Sg_i?)E-Bt&@v$pR?Y)UyUo)jG3~Y*qwnQS>>Go^(Y!%
zjlFX&B4kqqbxsVG_#|NMR4hWHW3XUN3<8f~4Z`yETw;A3vN!y+omRTWu+~Yz8hu%h
z`+4}!@va?dZ_U{XX@3eQ^3s_(zwg_D<V}@SCF*?VlGSwf{adcN(TQpjqoC#;xw#bb
zn>aCA(gGbvzc2d^i2#>B?v~z&RvqzQe65VS{CL~%AkSIB+`7)?bIX0tn(IgO-?pyT
z$0odO`6aZQ{1nPm>RYJrz51QSxBY=M?xuZcV0N*FiL)>H`PW{TjYGTLVFoZbOH^z0
zL0fQv(WjTEvtn3aEZI8f_a?WD*hTr?>IxQBm&rfFXPX;P7DV@_NRB4<izlFD$}V95
z5(pRttd^(a(oi5I`3Axe&LrxN%hXq%zyU@^VujIhEHHdB(Ocz5S_ud(<v39TE*Q5+
zw96kU#(ls!!43TV7CDi?%`)@q6pWtY<YrMx;O5mX5cHerNaj++5HVj1HGH{FsDygU
zW@?@zhwuXjP*2d;53eCee_JVECd2yJl?RT!!5G3|N08yNUOYFiZvlL#3h%3C!ZlEB
zY>Thj@roX@-*tO`M^C{8dYbBvF$JBt{0lTedE~Cr!>NVC^Br+QZmM{<kXcx^0A*|Z
zfcCIRD*4dd#P<C$@@VtDEJoUtKrZ8lIMi3igm?lR2HYAKgQBil-;+J=vY$z?d8LMu
zXUVzMz$E~#RG~{d1iEC;UwNSJlKx@|KE&1JW{z7t(f0eBlR{)})~_rOQ}K*p5>hG@
zxF_F_&zO`jzw!&GbK{n83hf3D9vCFg_ZK(PFpiqFe3ELz1bx?WOjEqgv3bkn<Lfvh
zGv-(<mD0C$2`Xkv4n(%kM(!dJ)NwK=sud*?;*jE14l1Y+pr_g5h$b`X^Lt!kOlgB|
zmn^5{0i_@wnB^ES%i~-5>v5OS=@y_sw(G(`!LSFr0oc1cU|_Mrv`Lxzqc-0G2gtaJ
z7R-YucOjR;13};(3n-@&lw1$t*DxKCO*aYd<I_dRxyM52kZ9jF6?O&yRZSGA6%>6=
zB!N;H@c1P);AU}$u-kjA-eC^_<S9umpjTls$9mLM<sH_j89DC)QzRMcwd$$|ktHN$
z>dD$aqf|$M+Cl%Tc7A66b;of1)s_6KcBpYt|41R4_CC{uCGXB;!(H_nqh5IKi_tB5
zk#l+eMJUh3saRIrl1_qD+hqTDAJ@_%CGJW$S;;Dc3N3b+H`{hi{B;A?Q7^Ns>XGY0
z;;My7L#y&dW~G`er_wwpYF*Q9<Iop`EE@c-9bF^_dYV0SORsZ2vwN?n!9w9cs!rnT
zNM|tU%}cVU8+K3J=+8WQ{iND)AbHEB-rBs$nsoc3m70yE_;5>&?kfSEy-n9%ohx(0
z5k|H;1Ly@prgZv~ttnAy`9WbY%Y$W7IiD4*r_H3!f=_k4HR4Cm7k1thLDDA9e(vNo
zso4<u@{oFLz%{j+06F}@w60;?dprZDBRir8EB_JUu?QTr|3dWs%66jpo$b_6+Lpj3
z=|$rI`rAShO%4|Uw<o~<NseuZ0yCVi<h{|nLM{2yU+4NmXFh;Fmb5LtA&9xZZ_;`=
z*@xf^KT5H<FJMq0ryv|rQ`*s+r+4-}<ndLN_r=(=DI}=|8`FC->5<SMZNh4G`u;&b
z5s%hJa{Zpy+X&yTv&ffz8f5*(9uxzKqu~zn{kA?@%`LmRCGk|;8E55tpule4@J4vP
zKZ9L2uRzY##`bm0HNU%-u@38#`MTGF6g_O5sJ*EI>))`X@~T~hxQF;@dP`<crkXaI
zWwW9*ixm|JF^FfN=Unn5D*9i!c`a|baWG#EPV~vXsQ29e{7B2)t!<{1-4|_-=(9Z&
z*3KwjYMgr7%;qo6+I2HRbT4is?5YAB9eD-WY;Vy3avQU{>nx)mzl}1Qjxlv^rxeHB
zcH<Q-3|S=U&(5}v!}tKnC55(MlMl&RXKn^(+8i&3Vz&jI5L8Hry^2gw$-+(foA`xH
zH73Bn#Z3eTa(c>tIEMQQ{Dl9P!u_W?{Di{IvUmCTJoM`nForiMe}QI%Xme=!u><hm
zM{iZ+7e~!RKHA#_2^oCdncHc`09>-9Dl_gj+Vs7?P@b1jad&sMjgafBEbG#VG!z<&
z(TjPX6?Wfku<(*&B#}(A*0@0Pp6%Xd8*bvB>q}Friw`!89;&9UEj)cxVs%fYDopnb
zN*PueRN6l9*>F|qoCx)g{v@+T+s5M(Kf;Xv`o~tAR63?7Pj{yKO4(^Dc%If9b(Q#i
z`IQib`<zq7Y^9jjbpGR5b&bHCi#H#98GiU94A#%M;k)?M@lC`O^TAf0-S>U|H$O$x
zM@U~OEMJE1a2_-lF}}%v+@kQK!DCE&MVvDC*N=mYvp=@pe@mdI1%8Goc2)dL6ijX=
zM>8VOo&cp*WZ{YBByOVo5WmWe;nY`Gc#xce0kbN6sR#N9OodzNjX(O7j{c)(`74L%
z-=v*FtU2m0YR0ljfC6-b`j}UllD4!AAniUnH$AyG-$Uf3iXTUL7wM)lEx+`9+UlT_
zOFKn)eq%^LzgP)*vrf~veDF3xSzhN^Q_WE5sI6MuDo+fAf`ti>!11)jpd>sk2V~Q$
zjH6i%ePwT|F|t9lwa;1tJ^|fAwQ1)`?ag+!pvnFbzF;qFg`ggf1DhX%ZW=W_=U29>
zXaFVs+d<doPkbx*0$HeM#OK-e!pL<J$C|vSu0o`%wka%pWCJ_)tDiRK{@1A#=-Mt-
zUdpov9_{z+(p6^2n_^Eb?V7Na-u|ZchD6Z++7S7*J<jh?-tRcsa@l@#t|sO}dgM@8
z-)(05w5cmUf9|YKF57r~ZDZgLWg&Zlq@HXZ8+8Ud6A4_uUI*((uhfj$+e7J82^>d_
zDmF?#oP0qSe^s9zj`I4x#6veYa}!J1$HB*Qu5Y)LJ@W0wG6)I<dS@7n0}D`fUU<4|
zY6?#n&6Eb3c#|&#=42UOdJsHhcUDc5(FA8A@K)aOwtJ@Z-3Znp)d%SLrF>sriGDP#
zTS=uRPfp1K?3#Mx>Eg(nGo(V^lj?})4XZBY3_w@w<CC(8u&l`43|N}SW?M-CSLbRK
zwL+i!A9X&bz<+0DPKx87z}#P&9Rl+YYfkt#ug+IA$Gqy+SWVmKnH!>I;bZlV?L=N0
zbwSzlj=K3fMYGjp;+6d>+de)`GUt~ObP5qnDP+bgq_X$w0h+bL<U=JYerp934`%>t
z4wHOuW0SjS*-n|BE_Spdfn4loHJjQp7#wX@=p*uhcJ&pj6D{U*_n@sp;H0o~FY(*@
z#cD&`(es(vD7ou<^{F4n8f?qSDc$6jl4Cq`P+WAwWliy?m}SR)%3h3aUAO2p`u1Jy
z{y{eggtYY49M!ktAb<35TR~V>4Mw5pA{3*Z%62hg{wIUxk)-#+^?Y-uV@==wBBkr!
z<|c+*(?~&ekNt1o{>0nHf9+R_jfZMau3})qiz;S44?>gHDTMVy8d*FGk&Nu+CV5Fz
zIqTw>(piqy0mTm-4p@+d^-#Jj=<4I_U~A4qti-_#pAII|8psd87_v;8q6zKM5O-hT
zHFU6>sju*}b3QS(uM}~UL&$h3QGD2qd_bg}lAe+kfdJbDGevij;kePnRt8&5;IRdZ
zdW17l<7XYwu%XQY+<Z;V4172$^Q>@d6MkCVYl@~rMbPfmArsumcz4Hqr?8kyR8&K<
z*BEGede_CHorpJQT45zVC_;5b8XAZIk=Z5cpZG4IjV*j^ckfo$dbsJZxkY)vU+jAT
z@1k+xx>_#EGXR>2$*=u0G?Vqe3hFOL5AcouHtkdsA=b}>S=t;vA<l8+Q6Z1j<f}_n
zew%hwUW*m55xG^<M9jsLx<hv^T<)CMx)YxRm(VP+_bnR;mI>r7gzHVQ<%k3D?$sOm
z;5-H+fyv&X#rR?a1q@kJx@Foah^L3ihrsk0B18f&gYD&h%uX4vSNA0ItWkr#f>Vis
z8bwXy!h+kDVH_d8T=Un32ny!5ijcKAz@k$x@mP`?y*xZI;@VGxq)z=@sW+|QKiO@Q
z&r7)C^j@b>`IavaeBSV=``xTz{3VK0W&Gr6p?hF*a>9DMW-FO;9K~xt{i8z=DLVQT
z^~CWW!SwQI%ZCmH=#N7CgRRApvgN}u@7}v#y8JKZk1l-Jt^5^J4F4K91TmlsByvW4
zoHWCO<99ps_#ptd7kKK+u2~ehKnYy&(0WMgbmoHZlsDxXj0p_YWdvlugQ0W<Pfg;i
zA?H12dU6CmHs(wp;KC3!Dv)7|nH~QIf^c)Fg1|7<&?rbcA#*5$ZNJmToR2k-K1pT`
zHm37yB6cYE(ya^1a5i7o49o3)`sISFeW7VqgbV=L<Cq~k@p=ghigp54M+Et5E{Yle
zb==B{asZI!DYpPvhRsXdEAxW@4E(lj7+#s*`9oVxmF1>;b=}no4+N$Y%I10Zk1i;I
z|4}ke@Fy+-THXU_{p9ahivC1O!ihaFGDq<1<%<BX*W#IQ&pbArhbQf)$<-6P&hkL!
zGM$S~jD)Api)wm~2iY{&wJWOqR|X2ZnB0IfNQG3X;=P@vy@v+QAUf+t?d?jVdj?fO
zd)V1lI*rD2lbU!3UYR=fcUON&kE$T3)k*@BUC(pLTH~lmo%uVHqctXn@i~5H?UVw?
zhQG5v?jqBDXu(;<sVN%!ApD2Sop;eN`tyQGaq*Eq&#U05_qTD58Dz@Qlp2QP&N{}D
zW-%I@t3NJ_lE+bEZsgxdC8cjOL}d33dWH+POZD9tUxQgPoeo}ux-Se#zwQX3pj;D|
zn$8K@N3CxM`bU$s5jfpGp*SPD-kDmtXRiPOLdB}lTH=EN`>cea)Z6Mo2o}e5r5~Rj
zrYnu%OUG>()}&0BCPFu(&h+5R0WDaBt|Q7dP{R^OVnnI3Y44t%4w4;kWB{Y<oQWqh
zJ1cz2B6P&hB%?V;?}F5wOnJ^w=0(k}-iJfkwqZ|)#JN~mjUZ(JrI+XRNUQ%0-UlFj
z*@v}G7X~g(5G<v;o0gTB%t^SCXgWY%0mcaUEK~jp0_+BL*h*2joRg61Z5LrY0uzw;
zXLpk%P#6E2@BY_3i9SvA_dJRDY|BHpvo~N=C_Wb!5C9`3Z-^9q8mG3*q5u{pZbsq2
z@wre(AHh&RuI}KSrDjjp4QCx1W|siA+e@H!8q6YS@5Z}jQkf`Hk))hDeHwyLSeHcZ
zo*oG{Pgg|v4@}pP>z~e}^k6D~L+vqfcqS0|J>eXf+w!50*1O6=&WD(P3^D@AR{ku|
zL|^v0_{>C%sTtV5201r&pzGgV&vnt&9o_rV`e1#M#u6Rg@`z?yA!z?_mE9CAJo_x6
zJb<*B4t9*(^K~zs@1JhwV;6h?JMzi%onvMBmM^f_O3***{eFByblg{e;QWpAqsgCf
zFi7@(O>!(&ZfU1Y)^p?yAPQ)GZ&X2sIyJjw`-V1~P=GmqGNbwT2Au7EJA^7Hqp84x
zXu^<lP)1<KuT0MClyZXhv7B=WreVOP=Wv6KT4p?A$$S4T1D)uMn)Fc<m^u8{a5*wb
z@>%?h5;NYnQ)F=SeiWRtu2e_V)7-^2b<7z{`khyy!;J+J38?E#7cQEqIkXw@ELIS%
zxK`HK<;&u_jPL=oxzj2EVMLNSaJ;OP;9m3TU(kvjcg6AH?^B8s)h$yh+SW+~Y;xal
z8w@yJ+^dQsKeXKmKX<4P$Cv}ucy0ZMwQA~HY#)~4RS)EZYpWx%%5^WgJ@5@Y#755s
z@E^@3m4G_>_e10_*7I*XppX52{bj&vBG#AO6lLF;PXF<xX96JFWqe)GT|0QI@+KXj
zA)2o-H1|A|ak(aChPJXZSIT=S>oi4M!tL`BOj%m=Riu1&3*l7ca1FjNGekg5lcy~j
z4$p<Xd}f4>p@E-A<HfZ`3dvEoO(Q6z?qVhFPbtfQya8Zst^VaxlyaR(zIk(4ENUUI
zC33!g@uTbD4R}WYJ<ZS4v&xi4zt+6xl-2YVB1o3@k+t8apIk>`oOr4l*i)F!+hRHr
zuJm+P=DwlUX(dZ-3E!(UC=c>3P>gI@e!z6}mCo<Nug#H<Eec%EL&PJ~kJWT0<zgg%
zu5<3FR7YG>Ic=KRe1;?kk^KGz%GZb{9FxPW(Nhjg&89Y9c>F^eX$6ibGBDhj07GtP
zXiO7W6B`jq-vu8cG1*VRsS>kV(#4nan=n9PMd$omMIgW+U1_La)ZRCUpRZrZFBA=e
z6$(mFNsq}mQgUzQx|Lo=m6+gRs6%2m12Zs$f=la}4I7C5wjZ+?I}n7mq;BPyj8wRI
zx+Z;3k(cX2E*GfYAI>!7>x}*@jzBz8v~ePrlL+LR@p+ZF0ruls06rp;+DeR&PB=J|
zQ&LT3-pxi<oRu0wG>kJVsir0_>~OUfcJIVr5&~yauB-K7`V)_!E>JZ89v%DxBK;>s
zj-u5T$w6lV5P6$JINWFIxyL)XfGAC0-gZRUxkuN=>I=JXeXUc=#70+W(J%|zZ=%}D
zdQz2^2grdgx;K%Yb%plA4fWXT+p#_nIT|ZTI3|rkGSogt(aoB&B1>+s5KrW7zMT~^
zWB$tBwp0C=tVy*ATt*TtCCJl8PVO_?$8Qz9B2ni-WhjVW8s;T$pX%nk#JqCxuDU0+
zNC@bLg#X^00eh9c=;8wxs*5Wnp`YPk()J#^>$&2Vh|1-%eL<>E9`{7Vu{p*K(?aJ=
z(kAA!^F>XFiSV^vqP?YJkRb|_gB!5h>0{ZjJsuENAdmL>QE;|&(=zwl>t}C@?mc?8
zN4c|ffaJT{7DI5lNd>d@m{E0XL)@c{C6oP0sRDr>3DM8EZ+A%+nX-mNkx4&M;32@_
zGCM_4&#9cz)Rwt3IB?&LKMflkwW%&m-))v1=S~&C4R!1sN|(r1y{fC&-?nTWB4A0v
zA&vpy*cUx_HC^fZdbz&hk+tJOl=5pQ2G4v(Rh-D6n?&mQmxBI%v~avRi$O@>W}7L@
z*|!zyybuM1r2u|b{R@VH%%Ki!0RV)|HVo1x@LH7I)L{yv*DpgjyL;4FG&^0+WZKP=
zH;9u<ubw46Ua-wn$7@RVHm$AQeg0D(TvL&m2N;>y7m_~LvwvbEXkG}kB%LJbdEM_3
zu5pTP$^(E%UZLF42mUvk#w@wa&z#(HZ`S{8rtm-Koz~!!dFS6%=~i8s0}IE>NxnIa
zQaFM(`c(c|0YUAbcvM+WJgd)%#0X5U1g5=X=A-6crE^Iv5aIQO1Nnl>_X0`?d^(9d
zi_MpEuNDm|$U|)pRz+7xp{moYlQlRrq!N9FB*_*i{HE5L#eNUPz+qNqn;Fmf+1SIZ
z(C+wNm*u{f!4r?J_W+SDZ27`|Pu%<Sw{s>>qpy#i^%D2Ce-yrP0hYq@0RQ+p&09{6
zTtBUzTi<;4L~d=nbXgX+j1;ge&5ii!KmS5`arM<GH*&20Fg<#)<vBF6vF`B7lP8W3
zZTGzbru;s>j){!#YyR#(_09-TOI}{v@z=cnP`(*QX(8scGE{Zir84^9J}0kNj{d8o
zL;xrd*O@AffgT@2SM08H@}JItA%N7H=u_HFq)2K7K_1*6b)X)=fBJ74?wI>bD>IB<
z*m|Xn98PUH>V(WFb?BgBk?<InA(i!{1N!3upg+D2p3y6VxSnZ$MZ@hFhLC;W^gLhM
zs4Pq44S#<;kTjCWdbP75bYrQepogL0g@xjIQ`Se?kX~xOBr)e_0YygD=h=&%1ON-|
zh)gNMCLb6%p4b>D6s%;u<w{QHZuE%g*>@VM^3(UK{ixg?4QF<#oP0CVF!q=L|7caR
zm{ra~DQ?gI^wHUw#;g1)60Yf-Pc_l+xxClM&svkBcV<7Dea%yh-0NE@Je@9O*HC=D
zdr)JLn)$-|p{z>TBY)4{M)-0vW|jbQ{<e8zqSbuyYeUA);&JjjRC`6puhHQEp9ew#
zvoT-qRBIBbFJ51JehqfY?onbA-KJl0Si#oF=(WpQW~wU46hnO_H{ZvmcGJ-8l8_f7
zz=biiK>wEMbLcnD=+Ya(Z-p}Z4bznx$I+#PAJBa*pg#rB=A&JIU21BU5%!b~h5Zlu
z0-dG(qV<9uKz@x*DFG_Ov1gT1651LCf}@FKY>FIYZSZ72wOPBLud_hpDxt*ebSs1J
znL14FjT5GY-iyW}er*$^Oc@3~{VP%1-NVHyYwiZNw29IEWhoaZD8=(cNExM9=ScIg
zoXc#u%6xTfG%h}jM1UQe+t)%l3-UbRb&+!J)oert5}~g8k(@A+TcqM{JrH@c_Gfx^
z;Q!~k_@~$jaI0)T$v}Eff_J7~l2_g5lkt_7q|6e`m@D#T{aEAGW56#HDkkZ4fF)wu
zX{h&O^Rw?e_5i|lT!F>Vk}6CtbpNMp`XWA0ot}5{_0Z|=RM9ge5w^V!<2$CIFshnc
zXMj;5%7uuX^)xBIym*I%rZ0n2=#pMU*>5VRh!_i+LryUZYUWDnTO<6?7BB5JFbq1r
zHC&Q{G1Euk%f_DZ*WH-7WgayYp&?vor`)A0Y|;Ifq+G&TGgp-Oy{7|q%!COE<XM{&
z4^7ZDE)&=|Q`GmbTx<wdCK=Cr{2-|9QMDAV5zg*VdENqj%v2rU_SIx>+kls(ZuQC$
z{;9j$O$M`b-K*c|Nt;{_NbhI01QLv5k+##GSrD~VI?i!b2DNW?P@&ro=5;6-dzqO`
zrH!!+N}f5(ZQ!VsavG^mEB=>2wyZ3sSDn1Opmto=tvHEapUTrOcw$JrCU7u+Hq3cI
zxdRGgB}-2GMVZ;E!^X7#&ItU@90f7b8PZoM<d|topMKpv;UHl`OMA2LfP8@NCL#2b
zNz<(^6Bs1}07w4nG{oZ0_W4_@%gag?;aEGPV4RjW=X-$tpw5gDem+3-fv5G5zS2SU
zRh*?=AAF@sc)~RsPWb{D`+p$K#oY2aTwRl|@3ZocfvW0eVNtrGQDisaTJ|uBUdWmC
z##S_aOaa0G3#y_$$-N*c|5$HgR|R@p8nrk)oXPs*y~mS5=r1aK?mynbF(=sc=cG6F
zFsqC+4Y=*mWS^IRM$g0mh4^ns=Kq>s6a*>7z#RX~Q?jgta3TO-wVz5;3II@lJUC}1
z00C><{E0OH#!(!yKGy)s5f>+O!K*WuzUmT$TlG-HeamGq<sz*cUN}=oy-Yt{;0{}c
zkW7{Sv|8cedA0aj$v9i8kK2o*A}CTk>X6ZM@IIKQfYW`i&?e0i%4MGSXw|Oze3fzr
zHslNb5#g!wF2%l(?Q6sjuI}pQE@&~`sWIn^qhu?jw6XY+XETzE1DEN8eQnGGO&{k-
zB-e*a`+do+`K8>gdvQf=$}>3nXCYq2W1;=lH;mV(hM~{WHs=r);T_L|b{67{xz9%y
zJ=QtJRYc7*%Pi`&InQ?ncHNvCMxM(|IqMK}Ohrp}P<$P96LmAJ<kt`ZN_no=K89&Q
zn$wNK-QFI~;sPuQp$i(%OaMn<!N_Bxpu-<Ys>J_zZv3Cl5y8isBKnVX35fL9$@^5N
z_>*?A?@r_ly%x`JKDOdSZgp)D*#^g++svNgF+vi&1NkiegN_0?hqpJ%7DgzO?k`;`
z*P!C9ev;+>rc|EBa6E4Y7Y~r@c(jF<5UE7(A=3-|o!1$934#?lO+p&c#ik8kDBU+Z
zoBihJ?i&T2wSDRCL5aE7CwbP6hShxdV>V53%e5ctv!AQnu@>EK_Z0_8(KfHN9DDaX
zZ@c6vS<&+54t$nz!M)!)P(b<)*ztjS4w39U>;Xpa9`QU*e0=^AVJaNP@;Q6G>(zv*
zCwu41hCcu6kqFA|&sF{ETMv7_3H0218~Sx~{uaNi{>M9(`(N6UPhXjT=2yDr{n+~2
zbeqN$^{%t)w412t^5nH2ue0qPdpWb(6pq{su+m2;aV+4N8R8CNXxYtyQzFV!Xc7Hj
zT^6{`T#5ijhs81q76Et|m=mM0Ai6{%7KE6&Q*z@q=LimxTpB!r=W`=E>2vBhj~be<
zH4(B5SQ*+}wc}*dbKc985V1DrL{B<Bz=Pb|3WOS=XooYAlwKuOML-%>RS};m5O)@!
zTu}jJ<CVCTC7;t?!MbrVM#C^Dxs^LHrj~*g1p*78Dq<wIy*mHT(y)sE{)PUBtnphR
z4X-9a0fqE0N0sH1vwQ#|$wJE$m$YH{=uOV{q`WVHNQ&IRgZo0yNqH1}6SvNxLTbIw
z>Mc!vQ799*9g8%qz~^!6T^+7zT7Fxif>f8%zP0w=*FxQ1>bEI|u1R~tl5uGygS$!G
z9#uIccovEYZw$@4_a>BU!1q8}oX|<`R$X%!h|hc|M46<waVV9dqk~Z7AgQDQh~(t{
zY78v8VfvMh^HC<*tfs{EPt;l&VD0Ibwg_Q?J6?<{y)1Cvu8-MuD#<8|>aBT~sJqh*
zx*9N{Mh`p1z@ch`=au!vPnTwbt{rb6#aA-Gj}9jt`xUvKdk*|~u(-OF^7Z<%>z+}<
zC7ROX<H@!tpSOD$7KZ~yUkasl9bPOL#p~M&;*^o*4!xWj&<TnRsHB9$H4m^Xwles4
z?j+|#ZgPQxIeqzd9lF;7PjvWne73hti?0j<%^=uXCNo{>aQq=nhIElRS_dB4s6`Es
z?PNg8kqSVz%fwt_6<Ct7^}soooRIA#RW{8Nvi;_4=TNrdcP0Z1N=@{Vt@Tr6l|8TX
z9h3Yku)H#($T^{O`JIzcj2rQe)8-a_M2P5b$-NcD2ZeDW7OLQ!DFBL8ep`DDb|;Or
zs#1L92s~C_pxN%$HP-iem?GUv&LBD6fVDL*fB{cqCztB_{a%Vc%2uoWkH+Ia#SLJ}
z$}}8R!t#&v{v=0(4W^x?Nt-MG`@A3DI+?Q4-1hqBGbNuUwfx#&NW4-9()(eeGk1uu
zw@C3cm@$mLYM@ZVL7-4}cvZgq{IOc+i5m|ItGTdvFuVw_VWmdjU^tb@3_-~!@_W#K
z?uce}v1Vs}Yb)<R_M+Fu^49u@9qogp-Wi?_>g&ITZ5+pd{5&)rB7MM|X~BYUitQE4
z(rH~r$%M7NGmI({lN|<7Ucm!GHyN1Dwn_By+uV$#Z3_R<nlps>x5v~B3&gG*3AeH8
zks)a+Ew##q`$ehWt^~n2$98eY^=4m-T0BQ%D0;@fA7GK8F<WoUC^C5z=LgS#T3Q6(
z61c6gu?hz|F=SvQgftMk>fp*K^NQsg2@0NzNtb|&*kjQ{rNL2Q`S+#uWsZ?qSeSwc
z3(&s?w5KU9OSRc0%Hp12O^*w5+A;gPCr#{lIh(Y2^a0xq4XGU(HU`Q4DB(eC|5Wii
z)i-rSl==_yQf1h(Kw#Dou`UptEeZ>*w_r>=cO!!79h9<jFEhgww^(GVB?O(rU)V#I
zx*C30eJ9?=SUXg@-D^ZyLP*=iK^o9}K&CIRN{S#I?_#DhJ79{2m8g@1s`(PN!D*@L
z!vxq#GW6a0cJAMz>n6UIPAI_RUh|-KG!%ml{@mEf^n-A(<Bwd?Pyc>2{oPT6KbZ#7
z`;7mC;J1aq^*#_OxQ}ot2M%SwgORK!(#oYc*p$=ct8pEOq>ZJ4ju1aCZBK6JK@szv
zC9OjF;Ie=V6)~hzF2xYhLuw)QI~%rgj7X_9;{wxbF5%zA1<axuFiyRj_MliwwYD!W
z*62C#L|1yr*{e9^BBL-x(MBQZn!X^N$8=dlXr8R|(D;aBRev&hx$JUMbG1}OFWjwr
z>y2yr<jcrIAI4UWM;?>Ux%GZICdaeC3c1&`0Q9w%sLWid^8iVMfRa8P${Iztww}HI
zX+gEs!X(6$!|E1C!$$h>NAjwJ++#k;U)4)%1^2H_4Gv6WAY7<`_pXEZ(E9;a?MFRM
z*B(b^wVvjVNcl9zW_ly8g4697$^vM|Q)Zkt1rZohw40<LI(CUcGs9EsWn~fe2=v4u
zmRnD7)Yl4!13}z!=4k{r31j;5shS~NroqUC4k&{lAz9*zJfMpN3(hCAz_yJGBl&Ej
zMnO<4`j$Nm?aQjR&9O3caS(%RGg67b=E$R$f(tL(bdB86(`*YhaCN0xbjc1G1pe39
z5#!Uwe2KJF;;~GYI;E`#@0H;+fr}t&4%L&yH9brBJDj2)1dR=Uog72qY_-+7z_C-Q
z@+%X_ba48ByIU7V6SP)WMW=cfi^&PQ`)4{vH&8tPlI#C&-Sa(RBk3bqw!Hq4swJ3?
zk4~gzoU0xOgtD8bKLYj-adIdnR4If-_ARgzN_zSpM5z7Jd2I&y@Ludgf$s91AUgRR
zp7@&ZNxE1TOUY$}LM{anDFBc=cYUkE@RsS&+Pgx8jjarLbr4$0s!o&&+nejVE`G{I
zvlN1)6I2vO6k25XOg=|ZDr4#2etP0F#HGV;IWE%u+=_Y3$n^^M#rvwumXAIglt5mJ
zz3&x!^p+#$_0>0{{DoNbB^p+`MA2sb$>^F`=eI4_Rvsmsl62X#C40Q)RoBcewwxCp
z>i_QTS8b(4>!)(0`&4$LBZ@EWzfE0^NmjB7`{4(H%M^InkO8x}!Gy=IkvzQ^okE$1
z`trv%51`Z|h+uQ~jPR@|j>AnLQ~a0aledab79QJsyI}-C%!7h_m&JLLWRTS3tJy%>
zUhgge0_zkkPeI1I-qv*^#Ny#>bGv$m7ONpBlUuCL7-Bb4*3?j^Z^+3oZTQhGB5?7X
z5;u3L;TP|J!E=WQk85lLm>*zn<C^!BK#q}@<iEw#Ie{w(0E9NUw<4s{6i5eNE{vMe
ziiVLh%HeVG0!hqB?<Ltkv*Zo`*8%dcgce|wcPbvcsr^?CybwJ5A(}wT6Q79gyWAbT
z@xlFtn|E#uiiSHri=}k#MJW6EsZOS|;NDzGZvf(YXxRi&B80IBNiIJxJm(-RWo|U3
zTZOml6VW69t4AoAfL!{<HIuTPMzvHeAof-Wsj4a*7at9waY^v$7rr$UC;j0W)pMrv
zT+eMaWEQ&eg1p;K#jbC30AU=8k%tFp^Ayv2qdie;t43qJmrDGO!Ujs*OwOyfc%6@3
z8cS9KlMfx@?q0?+>y62=U*BhcHqG_`Ua<9?sS-Ohn08}q{`BG(g42)s($&c?>$bBI
z3cYLfj~kK#oe!HXKGxn9Iv6i~Q>_2W#w>W|i$cfGZ`kng9WIWjqOi9SRmE6KqAw1;
z01`w;y!_QYP5|E^vrs&8awwEI3W(_rn|irlgynW>jT7r*@B=m+SeH?r)#t#MBr^12
z+CZ?nl{PqnB`WH&1gvKW%!!erH<F$WHqxMFkTt=D+VC%4)4zQu*~EM>b5VYF*LcAc
z8;Bxc0ITLwt{XTriJY3iY6#~7_@e@UAmFz!&<9{6?buk~DKP;-48SOlZKcTj8S8ua
zv0LluVoud(Rj?F+JU5(}g*Gp;!1TkP0k;2B<DC2Zq46Kh@NfRaR_1riJd@a9zUx3r
zEHL{$Nr(fYVVOR9_b<^p^~Nv?+7^8Gnd(aYXxRd6ZV?#BI}`XtgvH2qpcuQn`18Qm
z?OnN&^i{8kEOY_{DH`&`x2?mdSn|%fUnI#60%!gOP8<rO8Qq}S^{4{v7ccC;wHBCP
znfiefCSDqEqCL`)0M6drdssEV^(tbEmw$zo+4T||154IZKqbi*&KcftTy}e4&?vDe
z9v4-@&~mLDA^HSg%k4fCZDe({ve*W){`G82YX*el`gli3V^Vii`uz2=7ST;&Yx;)z
z6N71|qqnlVlAZLM$4`r1iaS)ccyBpMuSUUPsl;r%$QIdX^|b@eOl%24a=VYp)GnCe
zMM;X%I^^LE@gFPxR#DGJ;8So!g&&m?u%ISg?t5blXY9w3u~<kvYe|=ApCEm*@Q<7w
zn7#Vq?O}6<C!Ou&U`jL@DDz-Qmx3-zrX2tErC1WTXWhHkaU>Qp<_JfHfT%M^o8@})
zN4w>z+?3(YL+V;ons{)O&QPk{nlCvO4?G;7CBM@u<XXU9sImYz=PXU&l4T&0X);5A
zp<XPLhoE>zfI%D9#JQWy21txNxpB0G?(n4mLmM_3Nn;#m0KhK+exbGMQn}8RDhl_R
zT3G2#nh%89rZ5luz2<l<_|I6A&HpN%f1Nf!yCUT_9#sc`1AwCwlAvn}p#t)thDE`-
zFOoMTA3Z#vE|52*rAs=YPhN*I`&}-Oe#_r~oyV1F*nW2DVi8OFemE<r8XwE)iyo?x
zSbkrOE2fjO9I1U<X%RP?mGtoL`vz=B5+<p9{6(fsX!NONT1;#em!fK6nB=NOXen>N
zK`Yr;)0T)}TSlGn&8Y{Gi{hNt=6B;BZKKZ=ea;ZKed#TA1=j!M!T6i-0qywJ2{gd6
z(xII4<$Uy?-Jz-!3_LYf%D~ml^k)6rm6=g4@fVGcuW&c9u#P`7$qNYdiSGNl_$HX@
z84T`3f8}9!YC#Ng<9k-9#xK*o_w(Fe=qT?yKUY-b-BvIBa`buT)Oa)LP0*M%5$C&Z
zAkF4!;f(E&Ib3+Cj-Srp|6oVSw1Adgz&g%&Wj~EGwva!2AqU4>H>*JnTa{`T-*ysk
zymlp{iU~qVCSwd|?~U$H$HI{P;u+x>lB<C?0Ex1zwmLzmfxsq}kU(q})Eu}@Zd(PR
z7qg5b)!TFIg6u1^*nkBDd0z1o0=XWKg#PS0`T1Yh$-n5dlk3Do6EAoY<a#oMqvkkS
zFri*xt~mw3L?3JVR}5lc87QrIfC9GBJ+bVDBZo?0Fn)KR7n(*@Z;BKNc`u&cce_-i
zsqnK-GgIhYsCp^yFCncWQmJ0BI)AkT$mFis!?au4@6K4}n-|v?3L>pc8vVM`_*a>{
z$IGwL2Q<qv)PHDoJ#{?tA@l24WhhAFj^{T&%cqGy<`m>DHVwNnSUa-Zzdx87#7&<o
zI`ibgG^x($)zXU*iP?di)A@y=W-DtiDW47QXot(_hMrZa4<vK_%~q3>!{$0Vnz_|a
z*y@h`jY+-$A(ANShterdk!t-{Tnfm9v2x*IY?;b0>Vpldgtyb^<KyFSY<tw7Z84=F
z|9hwQZz8n%H*lkX>HMcg*cl>bRSMze<@#B|1EEf40mSOy`;!;bDY=qV4+v#lp*!L&
zZ*GX?V<2oUyu(rR3wlLzVm@aU(AD@GZ0ZG&1POQb9Pv24I!#7*!(xOoQ$HHWoufd~
z`Jyd$E6oZ=G5o#SgsyB3M0M1&1wPzxjmf<hC*d7sYP0ofP9wAQ!bfV%UO|jMx2w!4
za4CClf`JP>^6(jt+eHiCPfsCYr#=VM<Yi0U-=Dn1$5`;@u^F<8`hjI(F*&lJ_ngV|
zCX>eO&~HQWJmhhF`(L(%xyIMrb8CMXNX*Q(XM}u<Hu%&tY4mLZ-O<Foa-{Gxq^~!)
zs_N0y#gMJ2*RP)Ip~y47?=>eBTW#h7A<FBM--_(F3WHOWKKL$AD*Rx1SQ2=ZQC$Ty
zSoa_b&bol^7t63dxD|>Pz+=rJ&c0;67n+SG^;o_6vW=A8vBr^d(4`D=ivd+bZw-?;
zdVTv@K_^|lCO#THeRbKlnTp>TD>OM{QOaVi==sHLTc((PQ4g}vJDQe0z!B<I|5PB~
z!v`C!qR%)CH0|b5u0_|@R!P`EZNTVql9W~&98}T<zkWg66_+MgODO-N!50%y3IBh!
z__v=)eFgBl{Pr_>ofbLqGx53Ilx~<*&;0t~&iVn!sgs)4HlrYTixa><&7Y;Pv<>y=
zF)t6WFZrGB%uyoDVIIwt8^kDNf*G}kg_J3f0QE^`Qi;DKbJuduca|*cQu!CGCSG*S
z?2d9S#e#2R+(W;uwVL^$Dsr6$`;M@1a}-E2{MY`M`JQ@8@MGyJYR<ZNPnhDjgIUXt
zMWWpG?nI7Fwx=$iD#1@}edFI2WkD#ZWrnKGrGbjC@F)Mu=7B(czBfUi&VbtPg?$Gz
zqN#4L*-y2Mtokp-ghcDEA4myDJr5v-UN!o$ccF?VkA{+qE+DDrE9q)Y<!PFAT^zgO
zRRzHi8T2}r;^L&#>EaM(h`+v~r-&~ZY#5kWu$8xcvk4(NW8)Nl>I}Wcv=7hgi=4#@
zl$dv*vTe_79h{7-H&v(@kmy@h;g@CGO>oeHt3cwWj6@1Os+9q4JyYs30=T-#)L1E5
z&^W7pT8mqk=tO-TtyI=bhmG)orx|qZ3NMW6UC(e@l6Sos&~I-YMrs46sQ!*hdrB!p
zNjWTlr1qMrDyH>9trXJ|MNtmw03ck(B=P|WM2qzmEV~$20<fI+YhysjhUjWlW*Av5
z7C`yes{W`%`2Sua|IwkH$dyRL6}rDHZ<cjTKFD}rY1HKv-nW;#gEqu{D3=%JTZstS
z9HH+%McsKjt#OXxb1|(k%ouB|AOXlllaZBUEuD46Ax+NRbHHzs!)1gs2H!l*B-e~a
zXl@yGU#?D|p-kcJLi(`l7oU$|^IfE|OoGq}nw#7W<m!2>bbg_?T{TC^!}CeFd;5&X
zXuegT_}1YL*}ag}xz&eNdYl(MjCeQW3WmJj79-SCKX>~`JoQ;B;c*c4_kLekb!_ki
zwQwrSA>pI1kda!aW?lrp(NT6QITQvp9bwFf0)z+-b<Y$pHXr|J_~nt~R2-pX<b&tq
zqk)$tCqU<0CN(|FryXCprc@khr-e;FegeS|k#LffE{ZNEn<?Vs_c(TIV?s}o(!wT=
z41CHy!S<?+tkZ2c!mCVQaVX%u7N4kB$)p-+$px5G2?EmO(XL|})2W}?MKMvFyCAUU
zr?M3Bf!+6=;4_vC772PL{6NF68j6LA-*U>-6}j4FWOTj_Q*2;%0YQC1Ct#CN=i2Ls
zBe%RfWZRXvLo7y2JVs^H3wP}4(-?FDg_dCklrjA!u}n#nV(K{)6$N}JazMKJv$l$~
zAXIc&WY`1&nt#=!ttuZ_>rt6p_8o9UrPO-B%LEokcN^K@kk55Za(|>s{?C42{O{HD
zTVeWp%ckI_*?7{j{a!(~!3d_J;bQ{=T5T?-3P`o&Ki)6_6M1<&d{G;7FK)3f4*=0n
z9SJ#bDRgy>fB68Ay9Yii7+~?P;7mrO@iSvy-F)@(%R_rxb|%rfSEeLuGhNLZOr%t+
zZ)DaP6HPD`oJk}1EQrT~{WhZ)TqlZn2!ohBskO;gvHbn6>YcM6n#`EF6@HrVf~y=i
z!1eM^>h1dM7+qa{e)C$nTdu`@l<m+kUUz4!&*p>01BceoZy$WZ&CffP)m#Z))cLjw
zM7(khaeXka+bOhmh<7=6#dh!Wi*i1u?>y1x?0egjaoqYMLzfavl-$N!iy~sFzD}fv
z=!3uRCmze0k2e&*ilaUWzgOu)RuZBPL5LD4SU_VY2Bm)D{V>*4j{T#L7yI{{{y#q6
zzXUx&%wKu9fS^~;ns$<yI^2je>;jVTYZnBm65@$aA^9i1cyg_O3VN5aMHMhP0hFj@
zN~rhktZ#a!^$R!T=2n30SAzSGn?f1Htcur_7sb{fWA%%dqD^b|{2w)cR;|?QI?U2$
z+yFKA<@xSmamsPDcKM2h%p+bS&wp)eKf%swvhiK<--cWoowuNIr<c~+MBjcIQq4QV
zAo5ro|2!mJq%rWk9}z+5*x#KPyo&F9okQ}7NQsZ>t#Hk6S)V<p<l48sdMb#I0BzNY
zF{+Qqo0*JQw={Yaja_w{81iO5esNcy8+gKTh&3W#F3-$9t|@&LIAAAz0q)c1c{)NQ
za4u1|oSb{@fSigB*)+!OJ?9XgBd&>#I;D8HS;l>R=KGkvODK;$MDkbTP@>xp0<&#k
z*9bh-7TzhArZnG*%eZ#u7qc<ARwm{K5WLlhxO#K_{&e&vkirdyqOtTiB!e%Rm#=g0
zj4|$pDhYl_*y9Qew3sltCMV12;$R#GtmC-^EaA!Xs-H-cA59?=bIoox!6kYZYFvxD
z(Bzcoco3>paPyldAQC1|5ZJ_n!odj?+Esx5i?6u@pl|K~&yT6e<&N5=L2_n!)WR^a
zYpb<1jGe-oCp7lwKclfP0VVTq@a=B{1t6;JWT0T2sPf?-J-421A%q(ZZ2B_z@FEy^
zR9WS|a|BcIYOoELI3&IfJuTgmKQ>q%L&4+BJ4|xWlq!%FD_Z|fyQEYKzhSCc>tA!J
z3h&CKkn~Wv?=Jay)e53LAvW6Zioi>^=G9g{1_5nNQRtA6BosrE)DCp~n0@^Imqc7^
z2OOePnS0mu{G{Z0R8s9;A46j+uPc4{?4xvUY40DqHqQ+RSIl17O;SL#+7d*sukxDY
zf{}JDj?|S!rg<N>U(s;UeR6nw#WImeC=EN*Ge}r%zIg2-lnV^1i1<FPTduxg`7C1p
zs{XOM4eQ;6wamlWyFEn_@<H<j{&7cRt5;|c?|V*lClIe6M{1U^N4!S{bQ&R4ALuJo
zQ8ogDVl*(GVv^TjH3!FGLF8_}z_J#B6O8hduR*+1#Fpt4HVy4dK;GGPd@FWK^}&s^
zLl{20Brirml&m+VHHz-_r+J!?9|r*4J-5X&nM95Q8-mXk%uz~x!q4l7dS}4~eS{C4
zrj^i)s)R(1igyqQ97}AAVy?Yl2%{54<6!X-_L-U9vi7#7stRL_hNm5J7%hSD4k|q$
zk#nUyt*<<xSPXZo`h2fb?P_JOh*3N_k3wKIoGtcbTWke@_usAWtA#oy35U6z7-T)~
zJ$?_27HDo@?yB-^czmvJzll|@e!0(P@ZdPse*Izp5&fS4m6m@$ivE7`pQLp`R8&tK
zohPlPWmddMn^Gc*->@m?zRmNS8+AO6B+!CN#`e;{5HM1>;6$zXOcG%vFc2($@2m>;
z^69rX#9ZHJg%05^mD6S%S|92Of(s%1njs;$c0`S~l(^cX86n&`TeOp)CJ%xcAguKm
ztr%Ss;5>+%62UcHmNdwMu8(mlKI3^8UI!gykHyGFd<wAMY{jB3Ue6YIl%H(wHgVlb
z!RuL-e%}Z3!R`A-My;D~@9P~apb_O$infyHDpr=h-llGBxJ%90i#{V6z7>vMVMw<t
zqH4_+IFkRU0z0>VFe!%ho|Y1(E*m;FVZA1fgDmXIvO5mi@zdMcTzd6=0v%`ZZC&<Z
z@D-itq67<uVR7eDf(cBvvpikl2ZuidO4f4Q+^e)ugG%wxO@jdE>AYp^Yl>{*u?iE+
zp=P8BN6m&Oz1(8PAs!6r3rXlanhObH)IdRz9IdBf@GIk`;b5>-sRb8sXrKphJNCxU
zdKpSGgw;w2xa?s7Ygupf%W^Pedp(R-V+_!e{$%~I7kPf4VJLqG!#F5@pD~M!Q59Gw
zkj&vjL;^sIu%LJsWGz_)DdIwe@NoefzxcdFl`Gh>X6|=rRk6`n>J1DL7@CvSR#ybs
zufYq#qHbNn<N!b=ryD~FsJ3AA5PuKgD%$Ix9}Ri_ncU+7RM5XU?!Ul_zcW@@Shc^z
zWr*|@uBLO0ir6fc3}8CNI^FD9b>F7P9j!)(xj|a!3T5$Y`RsOfNi&cB%vxuTzwKKh
zATEo_X07OzqopuVk0JMW<%Y*Lo4z<@*bP>UD9U3`V3@)p-3dR(-!mG+YU}H;-FbN;
z4S%-xMHkQbOHDXRAjIe`>%?>Q?10|GhA8pteTkZ)A+ud)ua715dTM7?y}j;^*nK~C
zRzDg7MQP56dlx_8%73HSB}{}xYpreC&|z0Bt3bhX6GnF|_Px3+ST$vo2c`un2StZA
zhpv3Ger~$O#b^PIhC|X_zaNYBoS(X*l0&Q6R`jbbUW=!N3o&{=_x`p0FS7X~G;D;9
z4U3phtP(t}S_<<i^lv2>8vO?pUb5gbygo#jqR8E>Gt(7^$Zqy49^}v?z+`fZtd@K>
zSc3SkU5S2B`EJKsDS?!(q8m5PE*0XS2w=6;LkQVx#UmXRGB|%w&}|(UKPpkY;{}0?
z`K4ft7TBbDc}kxf16Tnl6VX76irxenF)ZcWGQ@Soj|UmO>twLiS7=_;@yctODB9VS
z)xTil)+mtAh2QKH|11B6a)%sFPHTyWvl{~kP_~O)`yD>f_$tHS=Cq15%i3zd>u6LF
zOOdx$U2~Ix>@Ex=zl&Fun2^IGnuG9n|Ez)nfeQNfbNAoE2jDb1nQx|<kDfS<fW*Mg
zN+E#iJO%>fMR`9wPx&hRNCkQB6Ms5djq4}&>copsw)0c+LJf}XL~+`nRtNgida2S@
zrqM{rYIvS%>QZ>NWI;88?Xp~i+_1n%x!iJd`1dXDxEKaH5h51lVNffZx$mSMcMpz4
zkiyp_m&l-x4d;`n9yf_Jp;+aOpSslBD)<i<kWq6yS{$i6ZsH*l%Rjb6PIm7N^=!nD
zbG#EY3wk{~0b(gXoaoqvQdI%oql{L<y5M-j%u-|>^XI5c&%<Y0_N`H|Ps2ZWsm7f#
z7cvq@)(&?pi-6iF2RFNpe~A5(_PuM46NoC|2ha@^#o@DrD;nRYO<qTfpmA?rUTg2v
zAc`J*Qkk+kxWUh%nQuZ%qd0`d5+Oq~9fO1x6Acz4B;FSy`J?(FIT*n}o32PILEZ8&
zv4Q=+_RcjN%5{z7gBdfk$v98Qn9;CJTjfx)a+nz^qX;23LXl%+Rw*LPG~-yyI4p9=
zVL64>DoKdS7*e9dv{Po}FpeFzh(ekDjJ5aG-fLg$x?Jnyx_o{=-uL^w?{oj}-~ZnW
zQ(=)P#LqgX9%*#~N(po1UFMLh&3WJ(w0%<v*y0w9qRczu!rX$mxH506<4SlM^q$VC
z?wyZj(#evR^V+GA&PwIa&%!sgz|fML!o-{^Ym6_a*s4HjaUQmUlK7?Pgg#$$)iUow
zcPjIhsgHK@r0pzY)EcUu51h<I<H@qinvPv%ExMZ@isOx)ChcW_zEP>RCoZT;&X{C@
z_$hSTe5z>qvl^z(%MAvs5~SKPCV5Bj^}8dl#ICFN{N?S<8u9j@NjR45bnV&}@96*6
zTfdoAVhOxeV1S4C#SI2-HWv9H3%%(qSnKIatWj-91>mF2YVeR6P&;18m3Ljh1L><#
zfp=hoYK*G%9YbJ&hS}NXv>(_jr|-Hl$e5n<mPDdW84)*z$gpIKI%Tt5uD7JB2QW}0
zSvg~s;WuRXt~;i=bVO*Hqw+=7rgI-M9iCNZRXd@MA~h-H*9-2(EcDN(_*dAwRRj}*
zCb^my1U{d(a4c%~p)_?al1)~^-X#R05cZ#HnR#UK>YAh{D`@=pq0yh;V|5~ojJ*m@
z2<7x+bPMn7LgGEY>NZz6O>yVKA31VJO>-54#5m$sjO}98Ky9bdmZjI11{w$Me}d#M
z&wUgoLR`c74gLkOlZ*50kOo3u>h54)`0GgbX9-Res8(2#K?4cLrp<;=yZ~9L;9ODs
z^4u#?c!{DE`{5lE<G#JswfCUyn6djMRjfVmkcSX_S!B8o`|S3Zp%x4WJ1WSq7q2~#
zEa5OOCL%?~B;{6v4C5F$XQ4=b@GHnE&jE21Wru|LQZOCiKJvSaZ>X%WguR;rq=-Pp
zq9|%jD-$eG_HU~9w<G00v(!!c&|mj0+XD0lFmNzS&3C2x0DyWMJ$T|7O)?E|su3(P
ztM)T<<Hw^bYWYoB+xL3T=vSi^lL@EZcTM%V;j;C#oNCaiy@*ZL;eKzCzZ|Ee$=?>#
zCM1pQFLQsr_%V0bJ06Nu4r9BZz^wD{*-zY;KXC3tafZMnFp#UD@%dpcEZgyKc6G$%
zmF3nUaVZ<Y$V)Y=?gBGgii$~07g|8HK+5nMU!V$&qLwG=52$BOKYfT*qmqk&MRCZn
zTYC(EZG1rUPuUiJdEhTO>eD$nN*wMGanz6c%5!kn1#g?L+`Yp6Lo{~gn~u5itzVVc
z+Ohm;y%{X+z=xZz8P_}bE9dJ?1>~Z3^L{=<d0&0xURj{4ah_-+dJ-hhrR=<2NXO_x
z5GG4_pB6D~X^tIj8uw700(B_5pucjpWIw){=g6bh5jrpchbHX<klF(~^JM|YIsl&j
zppdM1V^|vG*!ZOAKe&~4Bn`O`ZV&R<*?WWF8(SbUiw=<^E|S3O4jN)z%FZ0%BNTqn
zkPR$mTHPZ!<Xb-6Y<Dnf;k#5*U8Po%{h4#J7E&$P65wpCTr#P5RBy(<I6ht$kd7zf
z2<17UAc{c7VH&iIt9MXkxmyprDu(GcNkoQkBu!V{Ji}sHHr$zJmo|+9;;3k8%i4sF
zy#M*N`L9bCYj|~cA`vS}W)}$^FMdFa)8%kmN(1yacYvtFN1S;F?*tay>To^~I=V0I
zFq6ql7xQDIR4Ki@MCxE?mQdRPF{}{4@Y-=wzB}o3UvD{vvA;d?qu0IIJiML=DWXH=
zO^vTK)=ipT5l%DJ^M)b0wl{WDtw}f?Zt<RwGnY*2i;@DzNBGs*PgE3<ZW060DT*2W
z^w!xAK33P%?nei1+#_=$bBy%Z=griCh4N0cSti{nLe<&ed0(~}U|9hPBY{x#J02XR
z*U#fG)SUW9aIXYZDgLp9>5sE5v5o%>doy8IxZ9uM-6dQZSU5J-*{Hx3JKp7SKW6-<
z@x~+S?}=QP0^T@`gSsBEqT4HW-Xlj_HU`s119Y173}g4o2~BZY=*xs6quZzD!B>Y@
zg3>_u>^nlEgr^@Si!M`UgxSqDGPQD6x#8k>sWfsc9xVL5AQ?(aOGC9rogR?GSSPK1
zW-}3R`xzQs?S}JUh>(E?#1QXlmX|}FWv*!x)TPW0X^nQawcHCs=O7n%^7Hn!gVnzl
z>`v`GDG%T{6umGtVUUjxQ_q7jXP!#_8&T^FC{gu*%jbyh>9DM0xs_#j%DKPV0LLoO
zMJy3Doi1BhQJ~ybRjR>)VXN0Rm;K!l+xi0t0t#815>^G?JB3w)z(5E{Y+tp%kU(v5
z`h2pOL*JmW`=U<T(RStrg6GE~>SkaED6}pfN-JuCYY{yu1liKIShR<^;$_+xF;ffn
z{naUlA!LDCxcG*}RNsR+hTq+^NeUzMWf`R%W4y`;YR_`5)$CeRINEv%|40cxff9cC
zwS>eyEHF;6Oc=u43+|9&6X{ZF7Ww_#Moc0bbdULpqCGR@4;*g3iu18fLQT*VU(UK%
zXX-g8f0>Z?@66GSYCV0`(Yrg((oUSINd^uk!i~n=$d6u3gprr|mHI<N+(O*7S^Sit
zwoA(48qM==&)F`uM@*Wv+??BZ8U8R&`|2Nq`fvGWScIrt4(Ue;jaXY#&W<INXbsfx
znQ=p|k-Kc~HBU8Yk3TiAe4GK7es>?1orQDnzB6xd5D8t8syWI@e5Ix-7`)<s;ccwC
zF0>w-A3+_)$0YOs)pt&&r#NHgYts@*zW*A0E#BAb4fRJFYW+-DgaX1|2+{qs^v}2R
Me*LicZB0%71*%Lo^8f$<

literal 0
HcmV?d00001

diff --git a/docs/media/link-aha.tape b/docs/media/link-aha.tape
index 73eb3a28..ade6fbff 100644
--- a/docs/media/link-aha.tape
+++ b/docs/media/link-aha.tape
@@ -2,9 +2,9 @@
 #
 # Renders a crisp, deterministic GIF (no synthetic frames) with charmbracelet vhs.
 #
-# One-time render (needs ffmpeg, which most machines have):
-#   brew install vhs          # or: go install github.com/charmbracelet/vhs@latest
-#   pip install model2vec     # the fast local semantic tier
+# One-time render (needs ffmpeg + ttyd, pulled in by `brew install vhs`):
+#   brew install vhs
+#   pip install model2vec        # the fast local semantic tier
 #   cd docs/media && vhs link-aha.tape
 # Then wire it into README.md:
 #   <img src="docs/assets/link-aha.gif" alt="Link recall finds a memory phrased in different words" width="720">
@@ -15,29 +15,30 @@ Output ../assets/link-aha.gif
 Require lnk
 
 Set Shell bash
-Set FontSize 22
-Set Width 1240
-Set Height 560
+Set FontSize 20
+Set Width 1280
+Set Height 500
 Set Padding 44
-Set Theme { "background": "#221c12", "foreground": "#f3ece0", "cursor": "#e0955f", "black": "#221c12", "green": "#86c79a", "brightBlack": "#8a8174", "white": "#f3ece0" }
+Set Theme { "background": "#221c12", "foreground": "#f3ece0", "cursor": "#e0955f", "black": "#221c12", "green": "#86c79a", "brightBlack": "#8a8174", "white": "#f3ece0", "blue": "#e0955f", "brightBlue": "#e0955f", "cyan": "#d9b48c", "brightCyan": "#d9b48c" }
 
-# ── prep the demo workspace off-screen ──
+# ── prep the demo workspace off-screen; make it the working directory ──
 Hide
-Type "export L=$PWD/.aha-demo; rm -rf $L; lnk init $L >/dev/null 2>&1" Enter
-Type "lnk remember 'I like feature branches named feat/short-topic, never long ones' $L --type preference >/dev/null 2>&1" Enter
-Type "lnk semantic $L --setup >/dev/null 2>&1" Enter
+Type "O=$PWD; L=$O/.aha-demo; rm -rf $L; mkdir -p $L; cd $L" Enter
+Type "lnk init . >/dev/null 2>&1" Enter
+Type "lnk remember 'Name branches feat/short-topic, never long' . --type preference >/dev/null 2>&1" Enter
+Type "lnk semantic . --setup >/dev/null 2>&1" Enter
 Type "clear" Enter
 Show
 
 # ── the moment: ask in totally different words, it finds it ──
-Sleep 800ms
+Sleep 900ms
 Type@85ms "lnk recall 'how should I name my git branches'"
 Sleep 600ms
 Enter
-Sleep 2600ms
-Type@85ms "# different words, same memory — matched by meaning, not keywords"
-Sleep 2200ms
+Sleep 3s
+Type@85ms "# different words, same memory - matched by meaning, not keywords"
+Sleep 2400ms
 
 # ── cleanup off-screen ──
 Hide
-Type "rm -rf $L" Enter
+Type "cd $O; rm -rf $L" Enter
diff --git a/scripts/generate_docs_media.py b/scripts/generate_docs_media.py
index e79a530f..96f97cae 100644
--- a/scripts/generate_docs_media.py
+++ b/scripts/generate_docs_media.py
@@ -28,6 +28,7 @@
     "link-mcp.png",
     "link-memory-flow.svg",
     "link-aha.svg",
+    "link-aha.gif",
     "link-ui-tour.gif",
     "link-cli-tour.gif",
     "link-mcp-agent-chat.gif",

From 50ea15756e10ab962a2f4145df77a10df511ea3d Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 23:18:41 -0600
Subject: [PATCH 21/25] Show the aha demo on the landing home page
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The landing described the product and had a decorative hero graph but
showed no real product output. Embedded the animated demo terminal
(the existing self-contained link-aha.svg) in the 'How it works'
section, right after 'the agent builds the memory' and before the
Capture/Compile/Remember steps — a 'here's the payoff, then here's how'
beat.

Verified with a headless-Chrome render of the live bundle: the first
insertion broke it (the landing template is JSON, and I'd escaped single
quotes as \' which JSON rejects). Reverted and re-inserted with
JSON-valid escaping; the page now renders end to end.
---
 docs/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/index.html b/docs/index.html
index e740cf53..24944ba4 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -184,7 +184,7 @@
   </script>
 
   <script type="__bundler/template">
-"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Agent sessions no longer start from zero: Link injects your memory automatically when a session begins, and proposes new memory when it ends — you approve every save. Notes and docs become an inspectable, source-backed Markdown wiki; recall is local and measured in the open, with optional one-command hybrid matching. One memory, every agent, your machine.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
+"<!DOCTYPE html>\n<html><head>\n<meta charset=\"utf-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n<script src=\"9159f326-506e-4840-8930-dfb47cea857f\"><\u002Fscript>\n<\u002Fhead>\n<body>\n<x-dc>\n<helmet>\n<style>/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"67a6abec-a409-4098-8256-d4ed54892632\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"b85a5ac2-aff0-4ee6-827e-66f0d2ae15ec\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"6557f8b9-88d6-4ddc-90e5-6017376e0986\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"282721b5-8530-4dea-bd09-f32f0a9cb58a\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"42404396-6667-4354-8daf-7a392c0f626e\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* cyrillic-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"cca66aaa-8447-4ced-a09c-ef03e3f88c8b\") format('woff2');\n  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;\n}\n/* cyrillic */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"ca1df7a8-e7af-47b6-8b42-188d5bda8309\") format('woff2');\n  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"18c42a16-46a4-46d6-9856-1cb1f10c8835\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"9058dfdd-7e4a-4d1f-b85f-93d7d559c08b\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'IBM Plex Mono';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"5208e562-c9e0-4dd7-b012-e7dd89908452\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"35d7f364-08a5-4f00-9c4c-1ac97ca50386\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"43601ddf-4575-40aa-8c92-7d9ebe81fca7\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: italic;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"1a7bec6f-fb6c-4dce-9530-91b59d946d60\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 400;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 500;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n/* vietnamese */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"831bc54c-f2f0-4cb0-be23-528aeaa55c34\") format('woff2');\n  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;\n}\n/* latin-ext */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"295e6357-8e63-471c-acb8-855e23498be4\") format('woff2');\n  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;\n}\n/* latin */\n@font-face {\n  font-family: 'Newsreader';\n  font-style: normal;\n  font-weight: 600;\n  font-display: swap;\n  src: url(\"86898609-edeb-4461-b06c-c3dcb0901750\") format('woff2');\n  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;\n}\n<\u002Fstyle>\n<style>\n  *{box-sizing:border-box}\n  html{scroll-behavior:smooth}\n  body{margin:0}\n  ::selection{background:rgba(168,73,47,0.18)}\n  @keyframes lkFade{from{opacity:0;transform:translateY(6px) scale(.92)}to{opacity:1;transform:none}}\n  @keyframes lkRing{0%{opacity:.5;transform:scale(.6)}70%{opacity:0;transform:scale(2)}100%{opacity:0;transform:scale(2)}}\n  @keyframes lkBlink{0%,100%{opacity:1}50%{opacity:.25}}\n  @keyframes lkShimmer{0%{opacity:.45}50%{opacity:1}100%{opacity:.45}}\n<\u002Fstyle>\n<\u002Fhelmet>\n\n<div style=\"min-height:100vh;background:#f4eee1;color:#221c12;font-family:'Newsreader',Georgia,serif;-webkit-font-smoothing:antialiased;overflow-x:hidden\">\n\n  <header style=\"position:sticky;top:0;z-index:40;background:rgba(244,238,225,0.82);backdrop-filter:blur(10px);border-bottom:1px solid rgba(34,28,18,0.12)\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:14px 28px;display:flex;align-items:center;justify-content:space-between;gap:24px\">\n      <a href=\"#top\" style=\"display:flex;align-items:center;gap:10px;text-decoration:none;color:inherit\">\n        <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n        <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n      <\u002Fa>\n      <nav style=\"display:flex;align-items:center;gap:26px;font-family:'IBM Plex Mono',monospace;font-size:12.5px;letter-spacing:0.02em\">\n        <a href=\"#how\" style=\"text-decoration:none;color:#5f574a\">How it works<\u002Fa>\n        <a href=\"#memory\" style=\"text-decoration:none;color:#5f574a\">Memory<\u002Fa>\n        <a href=\"#tools\" style=\"text-decoration:none;color:#5f574a\">Tools &amp; CLI<\u002Fa>\n        <a href=\"#setup\" style=\"text-decoration:none;color:#5f574a\">Setup<\u002Fa>\n        <a href=\"getting-started.html\" style=\"text-decoration:none;color:#5f574a\">Docs<\u002Fa>\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#fbf7ed;background:#221c12;padding:8px 15px;border-radius:4px\" style-hover=\"text-decoration:none;color:#fbf7ed;background:#a8492f;padding:8px 15px;border-radius:4px\">GitHub ↗<\u002Fa>\n      <\u002Fnav>\n    <\u002Fdiv>\n  <\u002Fheader>\n\n  <a id=\"top\"><\u002Fa>\n  <section style=\"max-width:1120px;margin:0 auto;padding:72px 28px 80px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n    <div style=\"flex:1 1 440px;min-width:320px\">\n      <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#a8492f;margin-bottom:22px\">An open-source memory layer for local AI agents<\u002Fdiv>\n      <h1 style=\"font-size:clamp(42px,5.6vw,68px);font-weight:500;line-height:1.04;letter-spacing:-0.02em;margin:0 0 24px\">Give your agents<br>a <em style=\"font-style:italic;color:#a8492f\">memory.<\u002Fem><\u002Fh1>\n      <p style=\"font-size:19px;line-height:1.62;color:#5f574a;max-width:31em;margin:0 0 30px\">Agent sessions no longer start from zero: Link injects your memory automatically when a session begins, and proposes new memory when it ends — you approve every save. Notes and docs become an inspectable, source-backed Markdown wiki; recall is local and measured in the open, with optional one-command hybrid matching. One memory, every agent, your machine.<\u002Fp>\n      <div style=\"display:flex;align-items:center;gap:10px;background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:6px;padding:12px 15px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a;max-width:30em;margin-bottom:28px;overflow:auto\">\n        <span style=\"color:#a8492f\">$<\u002Fspan><span style=\"white-space:nowrap\">brew install gowtham0992/link/link<\u002Fspan>\n      <\u002Fdiv>\n      <div style=\"display:flex;flex-wrap:wrap;gap:14px\">\n        <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;background:#a8492f;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\" style-hover=\"text-decoration:none;background:#8e3a23;color:#fbf7ed;font-size:15px;padding:13px 22px;border-radius:5px;font-weight:500\">Browse the source ↗<\u002Fa>\n        <a href=\"#how\" style=\"text-decoration:none;background:transparent;color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\" style-hover=\"text-decoration:none;background:rgba(34,28,18,0.05);color:#221c12;font-size:15px;padding:13px 22px;border-radius:5px;border:1px solid rgba(34,28,18,0.2);font-weight:500\">See how it works<\u002Fa>\n      <\u002Fdiv>\n    <\u002Fdiv>\n\n    <div style=\"flex:1 1 380px;min-width:320px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:8px;box-shadow:0 18px 50px -28px rgba(34,28,18,0.4);overflow:hidden\">\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 16px;border-bottom:1px solid rgba(34,28,18,0.1)\">\n          <div style=\"display:flex;align-items:center;gap:9px;font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#5f574a\">\n            <span style=\"width:7px;height:7px;border-radius:50%;background:#4f7a5f;display:inline-block;animation:lkBlink 1.6s ease-in-out infinite\"><\u002Fspan>memory growing\n          <\u002Fdiv>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.08em;text-transform:uppercase;color:#a8492f\">live<\u002Fspan>\n        <\u002Fdiv>\n        <div style=\"padding:20px 18px 8px\">{{ heroGraph }}<\u002Fdiv>\n        <div style=\"display:flex;align-items:center;justify-content:space-between;padding:13px 18px;border-top:1px solid rgba(34,28,18,0.1);font-family:'IBM Plex Mono',monospace;font-size:12px\">\n          <span style=\"color:#221c12;font-weight:500\">{{ nodeCount }} items in recall<\u002Fspan>\n          <span style=\"color:#5f574a;animation:lkShimmer 1.7s ease-in-out infinite\">ingesting {{ currentSource }}<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <div style=\"border-top:1px solid rgba(34,28,18,0.1)\"><\u002Fdiv>\n\n  <section id=\"how\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px 70px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> How it works<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:18em\">You curate the sources. The agent builds the memory.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 52px\">You never write the wiki by hand. You add raw material and say what to remember — the agent does the reading, structuring, and linking.<\u002Fp>\n    <figure style=\"margin:0 0 52px;text-align:center\"><img src=\"assets/link-aha.svg\" alt=\"lnk recall finds a memory saved in different words, matched by meaning\" style=\"width:100%;max-width:680px;border-radius:12px;border:1px solid rgba(34,28,18,0.12)\"><figcaption style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin-top:12px\">Ask in your own words — Link matches by meaning, then greets your next session with what it learned.<\u002Ffigcaption><\u002Ffigure>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">01<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Capture<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Drop notes, transcripts, articles, PDFs, screenshots, and project context into <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">raw/<\u002Fcode>. Originals stay immutable.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">02<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Compile<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Agents compile sources into inspectable <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">wiki/<\u002Fcode> pages — concepts, entities, explorations — every claim linked to where it came from.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#f4eee1;padding:30px 28px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#a8492f;margin-bottom:18px\">03<\u002Fdiv>\n        <h3 style=\"font-size:23px;font-weight:600;margin:0 0 10px;letter-spacing:-0.01em\">Remember<\u002Fh3>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Say <em style=\"font-style:italic\">“remember this.”<\u002Fem> Preferences, decisions, and facts become reviewable memory pages — with provenance, review dates, and expiry.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <p style=\"font-size:17px;line-height:1.6;color:#5f574a;max-width:46em;margin:30px 0 0\">Then any agent retrieves compact, source-backed context — through the CLI, MCP, official skills, or the local viewer — <em style=\"font-style:italic;color:#221c12\">without dumping the whole wiki into the chat window.<\u002Fem><\u002Fp>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:18px 28px 88px\">\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:24px\">\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f\">wiki/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The knowledge layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0\">Source-backed pages compiled from what you capture — concepts, entities, comparisons, explorations. Cross-linked, navigable, and every claim traceable to its origin.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"background:#221c12;color:#f4eee1;border:1px solid rgba(34,28,18,0.2);border-radius:9px;padding:30px 28px\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:14px\">\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#e08a6c\">memory/<\u002Fspan>\n          <span style=\"font-size:20px;font-weight:600;letter-spacing:-0.01em\">The memory layer<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:rgba(244,238,225,0.72);margin:0\">Durable, reviewable facts you explicitly asked to keep — preferences, decisions, project context. Each one carries scope, provenance, a review date, and an expiry. Trusted on purpose, not by accident.<\u002Fp>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"memory\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> The memory model<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Every memory is a file you can read.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 18px\">A memory is just a Markdown page with metadata: a <strong style=\"font-weight:600;color:#221c12\">type<\u002Fstrong> and <strong style=\"font-weight:600;color:#221c12\">scope<\u002Fstrong>, where it came from, and whether it’s still safe to rely on.<\u002Fp>\n        <p style=\"font-size:18px;line-height:1.62;color:#5f574a;max-width:32em;margin:0 0 22px\">Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">review_after<\u002Fcode> and stale context returns to a review inbox instead of being trusted forever. Set <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;background:rgba(34,28,18,0.07);padding:1px 6px;border-radius:4px\">expires_at<\u002Fcode> and it leaves default recall on its own.<\u002Fp>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">private<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">project<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">team · shared on approval<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 400px;min-width:320px\">\n        <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.16);border-radius:9px;box-shadow:0 22px 60px -34px rgba(34,28,18,0.45);overflow:hidden;font-family:'IBM Plex Mono',monospace\">\n          <div style=\"display:flex;align-items:center;justify-content:space-between;padding:11px 16px;border-bottom:1px solid rgba(34,28,18,0.1);font-size:11.5px;color:#8a8174\">\n            <span>~/link/memory/use-short-release-notes.md<\u002Fspan>\n            <span style=\"color:#4f7a5f\">● active<\u002Fspan>\n          <\u002Fdiv>\n          <div style=\"padding:18px 20px 6px;font-size:13px;line-height:1.95;color:#5f574a\">\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">type:<\u002Fspan> preference<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">scope:<\u002Fspan> project · <span style=\"color:#221c12\">link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#a8492f\">visibility:<\u002Fspan> private<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">review_after:<\u002Fspan> 2026-09-01<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">expires_at:<\u002Fspan> —<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">source:<\u002Fspan> raw/standup-2026-05.md<\u002Fdiv>\n            <div><span style=\"color:#a8492f\">tags:<\u002Fspan> [release, comms]<\u002Fdiv>\n            <div style=\"color:#b0a594\">---<\u002Fdiv>\n          <\u002Fdiv>\n          <div style=\"padding:8px 20px 22px;font-family:'Newsreader',serif;font-size:18px;line-height:1.5;color:#221c12\">\n            Use short release notes for public updates.\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:13px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;line-height:1.6\">Stored as plain Markdown · readable in any editor · versioned in git<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"tools\" style=\"max-width:1120px;margin:0 auto;padding:88px 28px;scroll-margin-top:80px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Built for agents<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 14px;max-width:16em\">Workflow-shaped tools, not just search.<\u002Fh2>\n    <p style=\"font-size:18px;line-height:1.6;color:#5f574a;max-width:34em;margin:0 0 48px\">Agents reach Link through the MCP server or the <code style=\"font-family:'IBM Plex Mono',monospace;font-size:14px;background:rgba(34,28,18,0.06);padding:1px 6px;border-radius:4px\">lnk<\u002Fcode> CLI. Same core behavior, shaped around how a session actually runs.<\u002Fp>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(320px,1fr));gap:28px\">\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">MCP Server<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">link-mcp · 6 tools<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ mcpTools }}\" as=\"t\" hint-placeholder-count=\"5\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#a8492f\">{{ t.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ t.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n\n      <div style=\"background:#fbf7ed;border:1px solid rgba(34,28,18,0.14);border-radius:9px;overflow:hidden\">\n        <div style=\"padding:16px 22px;border-bottom:1px solid rgba(34,28,18,0.1);display:flex;align-items:baseline;justify-content:space-between\">\n          <span style=\"font-size:18px;font-weight:600\">CLI · lnk<\u002Fspan>\n          <span style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;color:#8a8174\">same core behavior<\u002Fspan>\n        <\u002Fdiv>\n        <sc-for list=\"{{ cliCommands }}\" as=\"c\" hint-placeholder-count=\"6\">\n          <div style=\"display:flex;flex-direction:column;gap:4px;padding:14px 22px;border-bottom:1px solid rgba(34,28,18,0.08)\">\n            <code style=\"font-family:'IBM Plex Mono',monospace;font-size:13px;color:#3b342a\"><span style=\"color:#4f7a5f\">link<\u002Fspan> {{ c.name }}<\u002Fcode>\n            <span style=\"font-size:14.5px;line-height:1.45;color:#5f574a\">{{ c.desc }}<\u002Fspan>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:26px;display:flex;flex-wrap:wrap;align-items:center;gap:14px;font-family:'IBM Plex Mono',monospace;font-size:13px;color:#5f574a;background:#f4eee1;border:1px dashed rgba(34,28,18,0.2);border-radius:8px;padding:14px 18px\">\n      <span style=\"color:#221c12\">On the official MCP Registry as <span style=\"color:#a8492f\">io.github.gowtham0992/link<\u002Fspan><\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>pip install link-mcp<\u002Fspan>\n      <span style=\"color:rgba(34,28,18,0.3)\">·<\u002Fspan>\n      <span>also reachable via official skills + local viewer<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"setup\" style=\"background:#221c12;color:#f4eee1;scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px;display:flex;flex-wrap:wrap;gap:56px;align-items:center\">\n      <div style=\"flex:1 1 360px;min-width:300px\">\n        <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#c98a73;margin-bottom:16px\"><span style=\"color:#e08a6c\">§<\u002Fspan> Setup<\u002Fdiv>\n        <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 18px;max-width:13em\">Install, run the demo, wire up your agent.<\u002Fh2>\n        <p style=\"font-size:18px;line-height:1.62;color:rgba(244,238,225,0.72);max-width:30em;margin:0 0 14px\"><code style=\"font-family:'IBM Plex Mono',monospace;font-size:13.5px;color:#f4eee1;background:rgba(244,238,225,0.1);padding:1px 6px;border-radius:4px\">lnk try<\u002Fcode> builds a finished local wiki — raw sources, pages, a starter memory, backlinks, and graph data — so you can see the whole loop before committing.<\u002Fp>\n        <p style=\"font-size:15px;line-height:1.6;color:rgba(244,238,225,0.55);max-width:30em;margin:0\">Pick your agent to make it Link-aware in every session. Runs on Python 3.10+; re-run anytime to update code without touching your data.<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"flex:1 1 420px;min-width:320px\">\n        <div style=\"background:#1a150d;border:1px solid rgba(244,238,225,0.14);border-radius:9px;overflow:hidden;box-shadow:0 24px 60px -34px rgba(0,0,0,0.6)\">\n          <div style=\"display:flex;flex-wrap:wrap;gap:4px;padding:12px 12px;border-bottom:1px solid rgba(244,238,225,0.12)\">\n            <sc-for list=\"{{ tools }}\" as=\"t\" hint-placeholder-count=\"7\">\n              <button onclick=\"{{ t.setTool }}\" style=\"{{ t.style }}\">{{ t.name }}<\u002Fbutton>\n            <\u002Fsc-for>\n          <\u002Fdiv>\n          <div style=\"padding:22px 20px;font-family:'IBM Plex Mono',monospace;font-size:13.5px;line-height:2.05\">\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">brew install gowtham0992/link/link<\u002Fspan><\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">lnk try &amp;&amp; lnk serve link-demo<\u002Fspan><\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4)\"># → open http://127.0.0.1:3000<\u002Fdiv>\n            <div style=\"color:rgba(244,238,225,0.4);margin-top:6px\"># make your agent Link-aware:<\u002Fdiv>\n            <div><span style=\"color:#e08a6c\">$<\u002Fspan> <span style=\"color:#f4eee1\">{{ activeCmd }}<\u002Fspan><\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div style=\"margin-top:14px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:rgba(244,238,225,0.5)\">From source instead: <span style=\"color:rgba(244,238,225,0.8)\">git clone<\u002Fspan> · or open <span style=\"color:rgba(244,238,225,0.8)\">~/link/wiki<\u002Fspan> in Obsidian.<\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n    <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Integrations<\u002Fdiv>\n    <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0 0 48px;max-width:15em\">Works where you already work.<\u002Fh2>\n    <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:1px;background:rgba(34,28,18,0.12);border:1px solid rgba(34,28,18,0.12);border-radius:8px;overflow:hidden\">\n      <sc-for list=\"{{ integrations }}\" as=\"i\" hint-placeholder-count=\"8\">\n        <div style=\"background:#f4eee1;padding:24px 22px\" style-hover=\"background:#fbf7ed;padding:24px 22px\">\n          <div style=\"font-size:18px;font-weight:600;margin-bottom:7px;letter-spacing:-0.01em\">{{ i.name }}<\u002Fdiv>\n          <div style=\"font-size:14.5px;line-height:1.5;color:#5f574a\">{{ i.desc }}<\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fsc-for>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <section id=\"principles\" style=\"background:#efe7d7;border-top:1px solid rgba(34,28,18,0.1);border-bottom:1px solid rgba(34,28,18,0.1);scroll-margin-top:80px\">\n    <div style=\"max-width:1120px;margin:0 auto;padding:88px 28px\">\n      <div style=\"display:flex;flex-wrap:wrap;justify-content:space-between;align-items:flex-end;gap:20px;margin-bottom:48px\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11.5px;letter-spacing:0.2em;text-transform:uppercase;color:#8a8174;margin-bottom:16px\"><span style=\"color:#a8492f\">§<\u002Fspan> Design principles<\u002Fdiv>\n          <h2 style=\"font-size:clamp(30px,3.6vw,44px);font-weight:500;letter-spacing:-0.015em;line-height:1.08;margin:0;max-width:14em\">Opinions, encoded.<\u002Fh2>\n        <\u002Fdiv>\n        <div style=\"display:flex;flex-wrap:wrap;gap:8px;font-family:'IBM Plex Mono',monospace;font-size:11px\">\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">seed<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">growing<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid rgba(34,28,18,0.22);border-radius:20px;padding:4px 11px;color:#5f574a\">mature<\u002Fspan>\n          <span style=\"color:rgba(34,28,18,0.3);align-self:center\">→<\u002Fspan>\n          <span style=\"border:1px solid #4f7a5f;border-radius:20px;padding:4px 11px;color:#4f7a5f\">established<\u002Fspan>\n        <\u002Fdiv>\n      <\u002Fdiv>\n      <div style=\"display:grid;grid-template-columns:repeat(auto-fit,minmax(300px,1fr));gap:0 48px\">\n        <sc-for list=\"{{ principles }}\" as=\"p\" hint-placeholder-count=\"6\">\n          <div style=\"padding:22px 0;border-bottom:1px solid rgba(34,28,18,0.14);display:flex;gap:16px;align-items:flex-start\">\n            <span style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#a8492f;padding-top:5px;min-width:24px\">{{ p.num }}<\u002Fspan>\n            <div>\n              <h3 style=\"font-size:19px;font-weight:600;margin:0 0 5px;letter-spacing:-0.01em\">{{ p.title }}<\u002Fh3>\n              <p style=\"font-size:15.5px;line-height:1.55;color:#5f574a;margin:0\">{{ p.desc }}<\u002Fp>\n            <\u002Fdiv>\n          <\u002Fdiv>\n        <\u002Fsc-for>\n      <\u002Fdiv>\n    <\u002Fdiv>\n  <\u002Fsection>\n\n  <footer style=\"max-width:1120px;margin:0 auto;padding:64px 28px 48px\">\n    <div style=\"display:flex;flex-wrap:wrap;gap:48px;justify-content:space-between\">\n      <div style=\"flex:1 1 280px;max-width:30em\">\n        <div style=\"display:flex;align-items:center;gap:10px;margin-bottom:16px\">\n          <svg width=\"23\" height=\"23\" viewBox=\"0 0 24 24\" fill=\"none\"><g stroke=\"#221c12\" stroke-width=\"1.7\" stroke-linecap=\"round\"><line x1=\"6.5\" y1=\"5\" x2=\"6.5\" y2=\"18.5\"><\u002Fline><line x1=\"6.5\" y1=\"18.5\" x2=\"18.5\" y2=\"18.5\"><\u002Fline><\u002Fg><circle cx=\"6.5\" cy=\"5\" r=\"2.3\" fill=\"#fbf7ed\" stroke=\"#221c12\" stroke-width=\"1.6\"><\u002Fcircle><circle cx=\"6.5\" cy=\"12\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"6.5\" cy=\"18.5\" r=\"2.6\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"12.5\" cy=\"18.5\" r=\"1.7\" fill=\"#221c12\"><\u002Fcircle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.6\" fill=\"#a8492f\"><\u002Fcircle><\u002Fsvg>\n          <span style=\"font-size:21px;font-weight:600;letter-spacing:-0.01em\">Link<\u002Fspan>\n        <\u002Fdiv>\n        <p style=\"font-size:16px;line-height:1.58;color:#5f574a;margin:0 0 12px\">An open-source memory layer for local AI agents. Durable, inspectable, and yours — source-backed wiki pages plus reviewable memory, all in plain Markdown.<\u002Fp>\n        <p style=\"font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174;margin:0\">Stays on your machine · no vector databases · no services<\u002Fp>\n      <\u002Fdiv>\n      <div style=\"display:flex;gap:56px;flex-wrap:wrap\">\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Project<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://github.com/gowtham0992/link\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">GitHub ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/issues\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Issues ↗<\u002Fa>\n            <a href=\"https://github.com/gowtham0992/link/blob/main/LICENSE\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MIT License ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Install<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://pypi.org/project/link-mcp/\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">PyPI · link-mcp ↗<\u002Fa>\n            <a href=\"https://registry.modelcontextprotocol.io/?q=io.github.gowtham0992%2Flink\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP Registry ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Learn<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">LLM Wiki pattern ↗<\u002Fa>\n            <a href=\"https://obsidian.md\" target=\"_blank\" rel=\"noopener\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Obsidian ↗<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n        <div>\n          <div style=\"font-family:'IBM Plex Mono',monospace;font-size:11px;letter-spacing:0.14em;text-transform:uppercase;color:#8a8174;margin-bottom:14px\">Docs<\u002Fdiv>\n          <div style=\"display:flex;flex-direction:column;gap:10px;font-size:15px\">\n            <a href=\"getting-started.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Getting started<\u002Fa>\n            <a href=\"concepts.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Concepts<\u002Fa>\n            <a href=\"mcp.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">MCP setup<\u002Fa>\n            <a href=\"cli.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">CLI reference<\u002Fa>\n            <a href=\"skills.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Skills<\u002Fa>\n            <a href=\"security.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Security<\u002Fa>\n            <a href=\"scale.html\" style=\"text-decoration:none;color:#3b342a;border-bottom:1px solid rgba(168,73,47,0.35);width:fit-content\">Scale<\u002Fa>\n          <\u002Fdiv>\n        <\u002Fdiv>\n      <\u002Fdiv>\n    <\u002Fdiv>\n    <div style=\"margin-top:48px;padding-top:22px;border-top:1px solid rgba(34,28,18,0.12);display:flex;flex-wrap:wrap;justify-content:space-between;gap:12px;font-family:'IBM Plex Mono',monospace;font-size:12px;color:#8a8174\">\n      <span>© 2026 · MIT licensed<\u002Fspan>\n      <span>Memory that stays with you.<\u002Fspan>\n    <\u002Fdiv>\n  <\u002Ffooter>\n\n<\u002Fdiv>\n<\u002Fx-dc>\n<script type=\"text/x-dc\" data-dc-script=\"\" data-props=\"{&quot;$preview&quot;:{&quot;width&quot;:1180,&quot;height&quot;:860},&quot;animateHero&quot;:{&quot;editor&quot;:&quot;boolean&quot;,&quot;default&quot;:true,&quot;tsType&quot;:&quot;boolean&quot;},&quot;growthSpeedMs&quot;:{&quot;editor&quot;:&quot;int&quot;,&quot;default&quot;:1700,&quot;min&quot;:600,&quot;max&quot;:3000,&quot;step&quot;:100,&quot;tsType&quot;:&quot;number&quot;},&quot;graphAccent&quot;:{&quot;editor&quot;:&quot;color&quot;,&quot;default&quot;:&quot;#a8492f&quot;,&quot;options&quot;:[&quot;#a8492f&quot;,&quot;#4f7a5f&quot;,&quot;#7a5cab&quot;,&quot;#b5852a&quot;],&quot;tsType&quot;:&quot;string&quot;}}\">\nclass Component extends DCLogic {\n  nodes = [\n    { x: 220, y: 170, label: 'Memory' },\n    { x: 110, y: 95,  label: 'Capture' },\n    { x: 330, y: 95,  label: 'Wiki' },\n    { x: 95,  y: 250, label: 'Query' },\n    { x: 350, y: 250, label: 'MCP' },\n    { x: 215, y: 58,  label: 'Preference' },\n    { x: 50,  y: 165, label: 'raw/' },\n    { x: 390, y: 165, label: 'Decision' },\n    { x: 165, y: 295, label: 'Provenance' },\n    { x: 300, y: 300, label: 'Brief' },\n  ];\n  edges = [[1,0],[2,0],[3,0],[4,0],[5,1],[6,3],[7,2],[8,3],[9,4],[5,2],[7,4]];\n  sources = ['raw/standup.md','raw/design-doc.pdf','raw/chat-log.txt','raw/research.md','raw/screenshot.png'];\n  tools = [\n    { name: 'Claude Code', cmd: 'bash link/integrations/claude-code/install.sh' },\n    { name: 'Cursor',      cmd: 'bash link/integrations/cursor/install.sh' },\n    { name: 'Codex',       cmd: 'bash link/integrations/codex/install.sh' },\n    { name: 'Copilot',     cmd: 'bash link/integrations/copilot/install.sh' },\n    { name: 'VS Code',     cmd: 'bash link/integrations/vscode/install.sh' },\n    { name: 'Antigravity', cmd: 'bash link/integrations/antigravity/install.sh' },\n    { name: 'Kiro',        cmd: 'bash link/integrations/kiro/install.sh' },\n  ];\n  mcpTools = [\n    { name: 'status', desc: 'Readiness, schema state, validation, and safe next actions before a session starts.' },\n    { name: 'recall', desc: 'The one read path: startup briefs, answer-ready packets with confidence labels, wiki search, graph context, token budgets — optionally hybrid with a local semantic model.' },\n    { name: 'remember', desc: 'Durable memory only after explicit approval — duplicate/conflict checks, visibility, review state, expiry, provenance.' },\n    { name: 'ingest', desc: 'Next steps for raw files: source safety, stale-ingest detection, validation, rebuild checks.' },\n    { name: 'review', desc: 'Memory inbox, profile, audit, log, explain, archive, restore, forget — and a read-only consolidate plan when the backlog grows.' },\n    { name: 'admin', desc: 'Escape hatch for backup, migrate, validate, graph export, captures, and rebuilds.' },\n  ];\n  cliCommands = [\n    { name: 'proof', desc: 'One command that proves cross-agent memory continuity locally.' },\n    { name: 'try', desc: 'Build the finished demo wiki and run the 60-second proof loop.' },\n    { name: 'serve link-demo', desc: 'Open the local viewer at 127.0.0.1:3000.' },\n    { name: 'start --task \"release work\"', desc: 'Session startup: readiness plus a memory brief.' },\n    { name: 'connect claude-code --hooks', desc: 'Session hooks: the memory brief is injected automatically at start; session end stores proposal-only notes.' },\n    { name: 'semantic --setup', desc: 'Optional hybrid recall with a local embedding model — offline at recall time, measured in benchmarks/RESULTS.md.' },\n    { name: 'query \"...\" --budget small', desc: 'An answer-ready packet, sized to your budget.' },\n    { name: 'remember \"...\" --type preference', desc: 'File a durable, reviewable memory.' },\n    { name: 'onboard', desc: 'Guided setup for a real workspace and your agent.' },\n  ];\n  integrations = [\n    { name: 'Claude Code', desc: 'Aware of your wiki and memory every session.' },\n    { name: 'Cursor', desc: 'Ingest, remember, and query without leaving the editor.' },\n    { name: 'Codex', desc: 'One-step install, central wiki scaffolded.' },\n    { name: 'GitHub Copilot', desc: 'Source-backed context wherever you write code.' },\n    { name: 'VS Code', desc: 'Native integration via install.sh.' },\n    { name: 'Antigravity', desc: \"Google's agent IDE, wired to Link.\" },\n    { name: 'Kiro', desc: 'Scaffolds ~/link/ and registers MCP automatically.' },\n    { name: 'Obsidian', desc: 'Import a vault into raw/, or edit ~/link/wiki directly.' },\n  ];\n  principles = [\n    { num: '01', title: 'Every claim links to its source', desc: 'No orphan claims. Provenance on every page; confidence tags — high, medium, low.' },\n    { num: '02', title: 'Memory you can review', desc: 'review_after re-checks stale context; expires_at retires it. Nothing is trusted forever.' },\n    { num: '03', title: 'It stays on your machine', desc: 'Plain Markdown in a git repo — readable, inspectable, and yours. Never locked in a vendor profile.' },\n    { num: '04', title: 'Shared across agents', desc: 'One memory layer your tools share — and session hooks inject it automatically, so no agent has to remember to ask.' },\n    { num: '05', title: 'Audit trail built-in', desc: 'Append-only log of every operation; compliance-export writes a redacted handoff packet.' },\n    { num: '06', title: 'No services, no APIs', desc: 'Pure Python by default; no vector databases, no npm. Optional semantic recall runs local models, offline at recall time, measured in the open.' },\n  ];\n\n  state = { revealed: 3, srcIndex: 0, activeTool: 1 };\n\n  componentDidMount() { this._start(); }\n  componentDidUpdate(prevProps) {\n    const pp = prevProps || {};\n    if (pp.growthSpeedMs !== this.props.growthSpeedMs || pp.animateHero !== this.props.animateHero) {\n      this._start();\n    }\n  }\n  componentWillUnmount() { clearInterval(this._iv); }\n\n  _start() {\n    clearInterval(this._iv);\n    if (this.props.animateHero === false) return;\n    const speed = this.props.growthSpeedMs ?? 1700;\n    this._iv = setInterval(() => {\n      this.setState(s => {\n        let revealed = s.revealed + 1;\n        if (revealed > this.nodes.length) revealed = 3;\n        return { revealed, srcIndex: (s.srcIndex + 1) % this.sources.length };\n      });\n    }, speed);\n  }\n\n  buildGraph() {\n    const R = React.createElement;\n    const accent = this.props.graphAccent ?? '#a8492f';\n    const rev = this.state.revealed;\n    const edges = this.edges.filter(([a, b]) => a < rev && b < rev).map(([a, b]) => {\n      const A = this.nodes[a], B = this.nodes[b];\n      return R('line', { key: 'e' + a + '_' + b, x1: A.x, y1: A.y, x2: B.x, y2: B.y, stroke: 'rgba(34,28,18,0.26)', strokeWidth: 1, style: { animation: 'lkFade .7s ease both' } });\n    });\n    const nodes = this.nodes.slice(0, rev).map((n, i) => {\n      const isNew = i === rev - 1;\n      return R('g', { key: 'n' + i, style: { animation: 'lkFade .55s ease both' } },\n        isNew ? R('circle', { cx: n.x, cy: n.y, r: 7, fill: 'none', stroke: accent, strokeWidth: 1.4, style: { transformBox: 'fill-box', transformOrigin: 'center', animation: 'lkRing 1.7s ease-out infinite' } }) : null,\n        R('circle', { cx: n.x, cy: n.y, r: isNew ? 5.5 : 4.5, fill: isNew ? accent : '#fbf7ed', stroke: isNew ? accent : '#221c12', strokeWidth: 1.3 }),\n        R('text', { x: n.x, y: n.y + 16, textAnchor: 'middle', fontSize: 8.5, fontFamily: \"'IBM Plex Mono', monospace\", fill: '#5f574a' }, n.label)\n      );\n    });\n    return R('svg', { viewBox: '0 0 440 340', width: '100%', style: { display: 'block', overflow: 'visible' } }, edges, nodes);\n  }\n\n  _tabStyle(active) {\n    return {\n      appearance: 'none', border: 'none', cursor: 'pointer',\n      fontFamily: \"'IBM Plex Mono', monospace\", fontSize: '12px', letterSpacing: '0.02em',\n      padding: '7px 12px', borderRadius: '4px', transition: 'all .15s ease',\n      color: active ? '#1a150d' : 'rgba(244,238,225,0.55)',\n      background: active ? '#e08a6c' : 'transparent',\n    };\n  }\n\n  renderVals() {\n    return {\n      heroGraph: this.buildGraph(),\n      nodeCount: this.state.revealed,\n      currentSource: this.sources[this.state.srcIndex],\n      activeCmd: this.tools[this.state.activeTool].cmd,\n      tools: this.tools.map((t, i) => ({\n        name: t.name,\n        style: this._tabStyle(i === this.state.activeTool),\n        setTool: () => this.setState({ activeTool: i }),\n      })),\n      mcpTools: this.mcpTools,\n      cliCommands: this.cliCommands,\n      integrations: this.integrations,\n      principles: this.principles,\n    };\n  }\n}\n<\u002Fscript>\n\n\n<\u002Fbody><\u002Fhtml>"
   </script>
 <script>(function(){var T='Link \u2014 Local memory for AI agents',I='assets/favicon.svg';function e(){if(document.title!==T)document.title=T;if(!document.querySelector('link[rel=\"icon\"]')){var l=document.createElement('link');l.rel='icon';l.type='image/svg+xml';l.href=I;document.head.appendChild(l);}}e();document.addEventListener('DOMContentLoaded',e);window.addEventListener('load',function(){e();setTimeout(e,300);setTimeout(e,1200);});try{new MutationObserver(e).observe(document.head,{childList:true});}catch(_){}})();</script>
 </body>

From 42a24fc12fb05f57045551407ca92797da19de5f Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Wed, 8 Jul 2026 23:54:31 -0600
Subject: [PATCH 22/25] Fix automatic capture attributing assistant prose to
 the user
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Session-end hooks extracted the whole transcript (user + assistant) and
fed it to the memory-proposal extractor, which is speaker-blind. A cue
like the assistant writing "you prefer small commits" was mined and
proposed as the user's own preference — found while dogfooding 1.6.

Mine proposals from the user's turns only via a new roles= parameter on
extract_transcript_text; keep the full transcript in the raw capture for
review context via session_end(proposal_text=...). Precision over recall
for automatic writes: the user can always remember explicitly, and junk
proposals are worse than the occasional miss.

Regression tests cover both the extractor (assistant prose excluded,
user preference kept) and the hook (assistant-only session captures
nothing; a user-stated decision still captures).
---
 CHANGELOG.md                         |  4 +++
 link.py                              | 21 ++++++++---
 mcp_package/link_core/agent_hooks.py | 11 ++++--
 tests/test_agent_hooks_core.py       | 24 +++++++++++++
 tests/test_link_cli.py               | 53 ++++++++++++++++++++++++++++
 5 files changed, 105 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ce3a3c60..c8073c8c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -43,6 +43,10 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 - Added `lnk hook session-end` to turn an agent transcript into review-gated memory: it extracts bounded user/assistant text (skipping tool calls and outputs), skips trivial sessions, and stores proposal-only session notes through the same duplicate/conflict-safe capture path as `lnk session-end`.
 - Added idempotent, non-destructive session-hook writing to `~/.claude/settings.json` that preserves existing user hooks and settings, replaces only Link's own hook entries on rerun, and skips re-injection on session resume.
 
+### Fixed
+
+- Automatic session-end capture now mines memory proposals from the user's own turns only, not the assistant's replies. Dogfooding showed the assistant's prose (e.g. a summary line like "you prefer small commits") was being extracted and proposed as the user's own preference. The raw capture still keeps the full transcript for review context; only the proposal candidates are restricted to what the user actually said (`extract_transcript_text(..., roles=("user",))`).
+
 ## [1.5.0] - 2026-07-03
 
 ### Added
diff --git a/link.py b/link.py
index 8a7b9967..c6d88f29 100644
--- a/link.py
+++ b/link.py
@@ -1248,6 +1248,7 @@ def session_end(
     title: str | None = None,
     limit: int = 3,
     project: str | None = None,
+    proposal_text: str | None = None,
     json_output: bool = False,
 ) -> int:
     target = target.expanduser().resolve()
@@ -1272,9 +1273,12 @@ def session_end(
         path_source=True,
     )
     rel_path = str(capture_record["path"])
+    # The raw capture keeps the full session for review context, but memory
+    # proposals are mined from proposal_text when given (the user's turns only)
+    # so the assistant's prose is never proposed as the user's preference.
     result = _propose_memories_from_text(
         wiki_dir,
-        text,
+        proposal_text if proposal_text is not None else text,
         source=rel_path,
         limit=max(1, min(limit, 10)),
         project=project_name,
@@ -2162,9 +2166,15 @@ def _hook_session_end(target: Path, hook_event: dict[str, object], limit: int, p
     transcript_value = str(hook_event.get("transcript_path") or "").strip()
     if not transcript_value:
         return 0
-    notes = _core_extract_transcript_text(Path(transcript_value).expanduser())
+    transcript_path = Path(transcript_value).expanduser()
+    notes = _core_extract_transcript_text(transcript_path)
     if len(notes.strip()) < 200:
         return 0
+    # Memory proposals come from the user's own turns only. The assistant's
+    # prose is help, not the user's preferences; mining it would attribute the
+    # assistant's words to the user (found in dogfooding). The raw capture below
+    # still keeps the full transcript for review context.
+    user_notes = _core_extract_transcript_text(transcript_path, roles=("user",))
     # Skip duplicate firings for the same conversation content (e.g. /clear
     # immediately followed by exit, or repeated end events).
     state_path = _session_end_hook_state_path(target)
@@ -2179,14 +2189,14 @@ def _hook_session_end(target: Path, hook_event: dict[str, object], limit: int, p
         project_dir = _hook_project_dir(hook_event)
         if project_dir:
             project_name = _default_project(Path(project_dir))
-    # Only store a capture when the session produced memory-worthy candidates;
-    # otherwise every session would add review-inbox noise.
+    # Only store a capture when the user's turns produced memory-worthy
+    # candidates; otherwise every session would add review-inbox noise.
     wiki_dir = _resolve_wiki_dir(target)
     root = _resolve_link_root(target)
     proposal_limit = max(1, min(limit, 10))
     preview = _propose_memories_from_text(
         wiki_dir,
-        notes,
+        user_notes,
         source="agent-session-hook",
         limit=proposal_limit,
         project=project_name,
@@ -2200,6 +2210,7 @@ def _hook_session_end(target: Path, hook_event: dict[str, object], limit: int, p
         title="Agent session notes" + (f" — {project_name}" if project_name else ""),
         limit=proposal_limit,
         project=project_name,
+        proposal_text=user_notes,
     )
     if code == 0:
         try:
diff --git a/mcp_package/link_core/agent_hooks.py b/mcp_package/link_core/agent_hooks.py
index 0a1aa0e6..2fd63254 100644
--- a/mcp_package/link_core/agent_hooks.py
+++ b/mcp_package/link_core/agent_hooks.py
@@ -333,12 +333,17 @@ def extract_transcript_text(
     *,
     max_chars: int = 6000,
     max_message_chars: int = 800,
+    roles: tuple[str, ...] = ("user", "assistant"),
 ) -> str:
     """Extract bounded conversation text from an agent transcript JSONL file.
 
-    Keeps user and assistant text blocks, skips tool calls/results and meta
-    entries, and returns the most recent messages within `max_chars`.
+    Keeps text blocks for the given `roles` (default user + assistant), skips
+    tool calls/results and meta entries, and returns the most recent messages
+    within `max_chars`. Pass roles=("user",) to mine only what the user said —
+    memory proposals should come from the user's own words, not the assistant's
+    prose, which would otherwise be mis-attributed as user preferences.
     """
+    role_set = set(roles)
     try:
         raw = transcript_path.read_text(encoding="utf-8", errors="replace")
     except OSError:
@@ -354,7 +359,7 @@ def extract_transcript_text(
             continue
         if not isinstance(entry, dict) or entry.get("isMeta"):
             continue
-        if entry.get("type") not in {"user", "assistant"}:
+        if entry.get("type") not in role_set:
             continue
         message = entry.get("message")
         if not isinstance(message, dict):
diff --git a/tests/test_agent_hooks_core.py b/tests/test_agent_hooks_core.py
index 59825230..17e8e921 100644
--- a/tests/test_agent_hooks_core.py
+++ b/tests/test_agent_hooks_core.py
@@ -238,6 +238,30 @@ def test_extract_transcript_bounds_output_to_most_recent_messages(self):
         self.assertIn("message 49", text)
         self.assertNotIn("message 0:", text)
 
+    def test_extract_transcript_can_keep_user_turns_only(self):
+        # Memory proposals must come from the user's words, not the assistant's
+        # prose (which dogfooding showed gets mis-attributed as user preferences).
+        with tempfile.TemporaryDirectory() as temp:
+            transcript = Path(temp) / "transcript.jsonl"
+            transcript.write_text(
+                "\n".join([
+                    _transcript_line("user", "ok go ahead"),
+                    _transcript_line("assistant", [{"type": "text",
+                        "text": "Tests pass on broken things; eyes don't. I prefer small commits."}]),
+                    _transcript_line("user", "We decided to require signed commits on every branch."),
+                ]),
+                encoding="utf-8",
+            )
+
+            both = extract_transcript_text(transcript)
+            user_only = extract_transcript_text(transcript, roles=("user",))
+
+        self.assertIn("Tests pass on broken things", both)
+        self.assertNotIn("Tests pass on broken things", user_only)
+        self.assertNotIn("I prefer small commits", user_only)
+        self.assertIn("signed commits", user_only)
+        self.assertIn("ok go ahead", user_only)
+
     def test_extract_transcript_handles_missing_file(self):
         self.assertEqual(extract_transcript_text(Path("/nonexistent/transcript.jsonl")), "")
 
diff --git a/tests/test_link_cli.py b/tests/test_link_cli.py
index 33c2b3f6..fc7b9d4d 100644
--- a/tests/test_link_cli.py
+++ b/tests/test_link_cli.py
@@ -2971,6 +2971,59 @@ def test_consolidate_prints_read_only_plan(self):
         self.assertTrue(payload["captures"][0]["accept_command"])
         self.assertTrue(payload["captures"][0]["delete_command"])
 
+    def test_hook_session_end_ignores_assistant_prose(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-assistant-prose-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+        transcript = tmp / "transcript.jsonl"
+        # Only the assistant states preference-shaped sentences; the user just
+        # acknowledges. Nothing should be captured.
+        transcript.write_text(
+            "\n".join([
+                json.dumps({"type": "user", "message": {"role": "user", "content": "ok go ahead"}}),
+                json.dumps({"type": "assistant", "message": {"role": "assistant", "content": [{
+                    "type": "text",
+                    "text": "Tests pass on broken things; eyes don't. These are shell commands. "
+                            "I prefer small commits and short PR descriptions for this project always."}]}}),
+                json.dumps({"type": "user", "message": {"role": "user", "content": "makes sense, nice"}}),
+            ]),
+            encoding="utf-8",
+        )
+
+        with patch("sys.stdin", self._hook_stdin({"transcript_path": str(transcript)})):
+            with redirect_stdout(StringIO()):
+                code = link_cli.run_agent_hook(target, "session-end")
+
+        self.assertEqual(code, 0)
+        captures = list((target / "raw/memory-captures").glob("*agent-session-notes*.md"))
+        self.assertEqual(captures, [], "assistant prose must not become a capture")
+
+    def test_hook_session_end_captures_user_stated_decision(self):
+        tmp = Path(tempfile.mkdtemp(prefix="link-user-decision-"))
+        target = tmp / "demo"
+        create_demo_quiet(target)
+        transcript = tmp / "transcript.jsonl"
+        transcript.write_text(
+            "\n".join([
+                json.dumps({"type": "assistant", "message": {"role": "assistant", "content": [{
+                    "type": "text", "text": "Here are some options for the release branch."}]}}),
+                json.dumps({"type": "user", "message": {"role": "user", "content":
+                    "For this project we decided to always cut releases from the develop branch, "
+                    "never straight to main, and to keep every commit without co-author trailers. "
+                    "Please treat that as the standing release convention from now on so we stay "
+                    "consistent across the whole team and every future release we ship together."}}),
+            ]),
+            encoding="utf-8",
+        )
+
+        with patch("sys.stdin", self._hook_stdin({"transcript_path": str(transcript)})):
+            with redirect_stdout(StringIO()):
+                code = link_cli.run_agent_hook(target, "session-end")
+
+        self.assertEqual(code, 0)
+        captures = list((target / "raw/memory-captures").glob("*agent-session-notes*.md"))
+        self.assertEqual(len(captures), 1, "a user-stated decision should be captured")
+
     def test_hook_session_end_skips_trivial_sessions(self):
         tmp = Path(tempfile.mkdtemp(prefix="link-hook-test-"))
         target = tmp / "demo"

From 2d2c32294a9b33f233fff6191b7f68dd387e160d Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Thu, 9 Jul 2026 17:41:12 -0600
Subject: [PATCH 23/25] Print usage on link_mcp --help instead of silently
 starting the server
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Cold-walking 1.6.0 as a brand-new pip user: python -m link_mcp --help
was swallowed by parse_known_args (add_help=False) and the stdio server
started, hanging in the terminal with zero output — a dead end on the
first exploratory command anyone runs.

Handle -h/--help explicitly before the parser: print the module usage
docstring (install, usage, MCP config snippet) plus an options list and
exit 0. Agent launch behavior is unchanged; unknown args still never
crash the server. Regression test asserts --help exits 0 with usage on
stdout and nothing on stderr.
---
 CHANGELOG.md                   |  1 +
 mcp_package/link_mcp/server.py | 16 ++++++++++++++++
 tests/test_mcp_contract.py     | 29 +++++++++++++++++++++++++++++
 3 files changed, 46 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c8073c8c..a2f382eb 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -45,6 +45,7 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 
 ### Fixed
 
+- `python -m link_mcp --help` now prints usage and the MCP config snippet instead of silently starting the stdio server (which hung in a terminal with no output). The parser still ignores unknown arguments so an agent launch config can never crash the server.
 - Automatic session-end capture now mines memory proposals from the user's own turns only, not the assistant's replies. Dogfooding showed the assistant's prose (e.g. a summary line like "you prefer small commits") was being extracted and proposed as the user's own preference. The raw capture still keeps the full transcript for review context; only the proposal candidates are restricted to what the user actually said (`extract_transcript_text(..., roles=("user",))`).
 
 ## [1.5.0] - 2026-07-03
diff --git a/mcp_package/link_mcp/server.py b/mcp_package/link_mcp/server.py
index 87d92896..25b5b524 100644
--- a/mcp_package/link_mcp/server.py
+++ b/mcp_package/link_mcp/server.py
@@ -35,6 +35,22 @@
 from link_core.version import LINK_VERSION
 
 # ── Resolve wiki directory ────────────────────────────────────────────
+# The parser keeps add_help=False and parse_known_args so an agent launch
+# config with unexpected args can never crash the server. Handle --help
+# explicitly first: without this, `python -m link_mcp --help` would start
+# the stdio server and hang silently waiting for MCP messages.
+if "-h" in sys.argv[1:] or "--help" in sys.argv[1:]:
+    print(__doc__.strip())
+    print(
+        "\nOptions:\n"
+        "  --wiki PATH        wiki directory (default: ~/link/wiki)\n"
+        "  --surface SURFACE  tool surface: slim (recommended) or full\n"
+        "  --version          print the link-mcp version and exit\n"
+        "  --semantic-setup   one-time semantic model fetch + index build\n"
+        "  -h, --help         show this help and exit"
+    )
+    sys.exit(0)
+
 parser = argparse.ArgumentParser(add_help=False)
 parser.add_argument("--wiki", default=None)
 parser.add_argument("--surface", choices=("full", "slim"), default=None)
diff --git a/tests/test_mcp_contract.py b/tests/test_mcp_contract.py
index 61e977e6..804b5065 100644
--- a/tests/test_mcp_contract.py
+++ b/tests/test_mcp_contract.py
@@ -403,6 +403,35 @@ def test_missing_wiki_message_points_to_current_setup_paths(self):
         finally:
             sys.argv = previous_argv
 
+    def test_help_flag_prints_usage_instead_of_starting_the_server(self):
+        # Without explicit handling, --help is swallowed by parse_known_args
+        # and the stdio server starts, hanging silently in a terminal — the
+        # first exploratory command a pip user runs must not dead-end.
+        previous_argv = sys.argv[:]
+        missing = Path(tempfile.mkdtemp(prefix="link-mcp-help-")) / "missing" / "wiki"
+        module_name = f"link_mcp_server_help_{id(missing)}"
+        try:
+            sys.argv = ["link_mcp.server", "--wiki", str(missing), "--help"]
+            spec = importlib.util.spec_from_file_location(module_name, ROOT / "mcp_package/link_mcp/server.py")
+            module = importlib.util.module_from_spec(spec)
+            assert spec.loader is not None
+            out = StringIO()
+            err = StringIO()
+            with redirect_stdout(out), redirect_stderr(err), self.assertRaises(SystemExit) as cm:
+                spec.loader.exec_module(module)
+
+            self.assertEqual(cm.exception.code, 0)
+            text = out.getvalue()
+            self.assertIn("Usage:", text)
+            self.assertIn("--wiki", text)
+            self.assertIn("--surface", text)
+            self.assertIn("--semantic-setup", text)
+            self.assertIn("mcpServers", text)
+            self.assertEqual(err.getvalue(), "")
+        finally:
+            sys.modules.pop(module_name, None)
+            sys.argv = previous_argv
+
     def test_version_flag_does_not_require_wiki_or_mcp_sdk(self):
         previous_argv = sys.argv[:]
         missing = Path(tempfile.mkdtemp(prefix="link-mcp-version-")) / "missing" / "wiki"

From e20d82457b21470a6574e437be9631b0c6d165b5 Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Thu, 9 Jul 2026 17:45:11 -0600
Subject: [PATCH 24/25] Prepare 1.6.0 release

---
 CHANGELOG.md                     | 2 ++
 mcp_package/link_core/version.py | 2 +-
 mcp_package/link_mcp/__init__.py | 2 +-
 mcp_package/pyproject.toml       | 2 +-
 mcp_package/server.json          | 4 ++--
 5 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a2f382eb..bf997b1e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,8 @@ Release sections use `MAJOR.MINOR.PATCH` versions that match `link-mcp` on PyPI
 
 ## [Unreleased]
 
+## [1.6.0] - 2026-07-09
+
 - Added an animated "aha" demo to the Getting Started page: a self-contained SVG (`docs/assets/link-aha.svg`, plain text, no external runtime, animates in any browser) showing the two moments Link is built for — recall that matches by meaning rather than keywords, and memory injected into a new agent session automatically. The README shows the matching recorded GIF (`docs/assets/link-aha.gif`), rendered from real `lnk` commands via a checked-in charmbracelet vhs tape (`docs/media/link-aha.tape`) so it is reproducible, not synthetic.
 
 - Fixed first-ten-minutes friction found by walking Link cold as a brand-new user:
diff --git a/mcp_package/link_core/version.py b/mcp_package/link_core/version.py
index df830011..35c92fba 100644
--- a/mcp_package/link_core/version.py
+++ b/mcp_package/link_core/version.py
@@ -1,4 +1,4 @@
 """Shared Link release version."""
 from __future__ import annotations
 
-LINK_VERSION = "1.5.0"
+LINK_VERSION = "1.6.0"
diff --git a/mcp_package/link_mcp/__init__.py b/mcp_package/link_mcp/__init__.py
index 90c25129..8a1e3b35 100644
--- a/mcp_package/link_mcp/__init__.py
+++ b/mcp_package/link_mcp/__init__.py
@@ -1,2 +1,2 @@
 """Link MCP Server — personal knowledge wiki as MCP tools."""
-__version__ = "1.5.0"
+__version__ = "1.6.0"
diff --git a/mcp_package/pyproject.toml b/mcp_package/pyproject.toml
index 1b46d8ee..864f2ea1 100644
--- a/mcp_package/pyproject.toml
+++ b/mcp_package/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "link-mcp"
-version = "1.5.0"
+version = "1.6.0"
 description = "MCP server for Link local agent memory — remember, recall, search, context, and graph traversal"
 readme = "README.md"
 license = { text = "MIT" }
diff --git a/mcp_package/server.json b/mcp_package/server.json
index 40470da3..95aff742 100644
--- a/mcp_package/server.json
+++ b/mcp_package/server.json
@@ -6,12 +6,12 @@
     "url": "https://github.com/gowtham0992/link",
     "source": "github"
   },
-  "version": "1.5.0",
+  "version": "1.6.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "link-mcp",
-      "version": "1.5.0",
+      "version": "1.6.0",
       "transport": {
         "type": "stdio"
       }

From cb739dedade9d631e048ba07abae22426262ad2d Mon Sep 17 00:00:00 2001
From: Gowtham <gowtham0992@gmail.com>
Date: Thu, 9 Jul 2026 17:51:19 -0600
Subject: [PATCH 25/25] Make hook-command path assertions portable to Windows
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

First Windows CI run of the hooks tests (CI is PR-triggered, so the 1.6
work had only seen POSIX until the release PR) failed on two assertions,
both test bugs — the product output is correct on both platforms:

- test_build_preview_includes_both_events_and_commands asserted POSIX
  shlex single-quoting; display_command intentionally uses
  list2cmdline double quotes on Windows. Assert the platform's quoting.
- test_connect_hooks_preview_includes_session_hooks_payload compared the
  absolute temp path, but Windows mkdtemp returns the 8.3 short form
  (RUNNER~1) while the built command holds the resolved long form
  (runneradmin). Assert the stable demo/link.py path tail instead.
---
 tests/test_agent_hooks_core.py | 8 ++++++--
 tests/test_link_cli.py         | 6 +++++-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/tests/test_agent_hooks_core.py b/tests/test_agent_hooks_core.py
index 17e8e921..acb8eee8 100644
--- a/tests/test_agent_hooks_core.py
+++ b/tests/test_agent_hooks_core.py
@@ -1,4 +1,5 @@
 import json
+import os
 import sys
 import tempfile
 import unittest
@@ -122,8 +123,11 @@ def test_build_preview_includes_both_events_and_commands(self):
         events = payload["events"]
         self.assertIn(" hook session-start ", str(events["SessionStart"]))
         self.assertIn(" hook session-end ", str(events["SessionEnd"]))
-        # Paths with spaces must stay shell-safe in the written command.
-        self.assertIn("'/tmp/my link/link.py'", str(events["SessionStart"]))
+        # Paths with spaces must stay shell-safe in the written command:
+        # shlex single quotes on POSIX, list2cmdline double quotes on Windows.
+        script = str(Path("/tmp/my link/link.py"))
+        quoted = f'"{script}"' if os.name == "nt" else f"'{script}'"
+        self.assertIn(quoted, str(events["SessionStart"]))
         snippet = json.loads(str(payload["snippet"]))
         self.assertIn("SessionStart", snippet["hooks"])
         self.assertIn("SessionEnd", snippet["hooks"])
diff --git a/tests/test_link_cli.py b/tests/test_link_cli.py
index fc7b9d4d..de6ab68b 100644
--- a/tests/test_link_cli.py
+++ b/tests/test_link_cli.py
@@ -3080,7 +3080,11 @@ def test_connect_hooks_preview_includes_session_hooks_payload(self):
         self.assertEqual(session_hooks["agent"], "claude-code")
         self.assertFalse(session_hooks["write"]["ok"])
         self.assertIn(" hook session-start ", session_hooks["events"]["SessionStart"])
-        self.assertIn(str(target / "link.py"), session_hooks["events"]["SessionStart"])
+        # The command must point at the demo's own runtime script. Compare the
+        # stable path tail: on Windows the temp dir in the command is resolved
+        # to its long form (runneradmin) while mkdtemp returns the 8.3 short
+        # form (RUNNER~1), so the absolute prefix differs.
+        self.assertIn(str(Path(target.name) / "link.py"), session_hooks["events"]["SessionStart"])
 
 
 class NewUserFrictionTests(unittest.TestCase):