memex-mvp 0.7.0 → 0.8.1

package/HELP.md

@@ -301,6 +301,10 @@ Memex по дефолту сортирует по **релевантности**
 memex search "Postgres миграция"                  # FTS5 поиск
 memex search "Q2 deck" --chat "Memex Bot"         # фильтр по title чата
 memex search "auth" --source claude-code --limit 5 --sort date_desc
+memex search "JWT" --as-of 2026-05-01             # time-travel (v0.8.1+) — только до даты
+
+memex when "Brian Chesky"                          # «когда мы об этом говорили»
+memex when "JWT decision" --limit 5                #  → chronological list of chats, без snippets
 
 memex recent --limit 5                             # последние сообщения
 memex recent --source telegram
@@ -310,7 +314,7 @@ memex list --source web                            # только сохранё
 
 memex get web-1582ab51a7b7                         # полный контент conversation
 
-memex overview                                     # snapshot корпуса
+memex overview                                     # snapshot корпуса (+ capture streak v0.8.1+)
 memex projects                                     # уникальные project_paths
 memex help                                         # эта инструкция в терминале
 memex --help                                       # справка по командам
@@ -338,6 +342,35 @@ memex get web-1582ab51a7b7 --json > backup.json
 
 ---
 
+## 🪄 Auto-context (v0.8+) — Brian Chesky moment
+
+Magic-фича. Когда ты открываешь Claude Code в проекте, Claude **сам** инжектит 500-1500 токенов контекста про этот проект — что ты делал недавно, какие conversations касались темы. Ты ещё ничего не спросил, а AI **уже знает**.
+
+**Технически:** SessionStart hook в `~/.claude/settings.json`. При старте каждой Claude Code сессии хук вызывает `memex context` → memex выдаёт markdown summary → Claude получает его как system message _до_ твоего первого вопроса.
+
+**Установка:** во время `memex-sync install` будет промпт `[Y/n]` — соглашайся (Y по default'у). Или установи позже:
+
+```bash
+memex hook install         # добавить хук
+memex hook uninstall       # удалить (только memex-запись, другие хуки сохраняются)
+memex hook status          # узнать текущее состояние
+```
+
+**Посмотреть что будет инжектиться** (dry-run в текущей директории):
+
+```bash
+memex context              # markdown как для хука
+memex context --json       # структурированный
+memex context --no-source telegram   # исключить telegram (privacy)
+memex context --freshness-days 30    # только последние 30 дней
+```
+
+**Privacy:** хук ничего не отправляет наружу — это локальная инъекция в локальную Claude-сессию. Но в context могут попасть фрагменты из любых indexed sources (включая Telegram). Чтобы исключить — добавь `--no-source telegram` в команду хука (правится в `~/.claude/settings.json`).
+
+**Где это пока не работает:** Cursor, Cline, Continue, Zed — у них нет native SessionStart hook'а. Fallback через MCP-tool — в roadmap v0.9.0. Сейчас auto-context работает только в **Claude Code и OpenClaw**.
+
+---
+
 ## Если что-то не работает
 
 ### Поиск пустой

package/README.md

@@ -107,10 +107,12 @@ The same `memex` binary that runs as an MCP server also has a terminal mode for
 ```sh
 memex search "Postgres migration"          # full-text search
 memex search "Q2 deck" --chat "Memex Bot"  # scope to one conversation by title
+memex search "JWT" --as-of 2026-05-01      # v0.8.1: time-travel — only msgs before date
+memex when "Brian Chesky"                   # v0.8.1: "when did we talk about X" — dates + chats
 memex recent --limit 5                      # last 5 messages across all sources
 memex list --source web                     # all saved URLs
 memex get web-1582ab51a7b7                  # full content of one conversation
-memex overview                              # snapshot of corpus
+memex overview                              # snapshot of corpus + v0.8.1: capture streak
 memex projects                              # distinct project_paths captured
 memex help                                  # full user guide (HELP.md)
 memex --help                                # command reference
@@ -122,6 +124,28 @@ When called **without arguments** (`memex`), the binary still runs as an MCP std
 
 ---
 
+## Auto-context (v0.8+) — Claude already knows what you were doing
+
+After `memex-sync install`, you're prompted to enable **auto-context**. When yes, memex adds a SessionStart hook to `~/.claude/settings.json` so that **every time you open Claude Code in a project**, Claude gets injected with ~500-1500 tokens of relevant context — what you did recently in this project, which conversations touched it, which related topics came up. No prompts. No tool calls. Just memory.
+
+```sh
+# Adding/removing the hook outside the install flow:
+memex hook install        # add SessionStart hook (idempotent)
+memex hook uninstall      # remove only the memex entry, preserves other hooks
+memex hook status         # show current state
+
+# Inspecting what gets injected:
+memex context             # dry-run the hook output for the current dir
+memex context --pwd /path # for a different project
+memex context --no-source telegram  # exclude a source
+```
+
+The hook respects existing hooks (e.g. `gstack`, custom user hooks) — they're preserved untouched.
+
+**Currently only Claude Code has native SessionStart hooks.** For Cursor / Cline / Continue / Zed, MCP-tool-based fallback is on the v0.9.0 roadmap.
+
+---
+
 ## Save URLs into memex (v0.6+)
 
 Once memex is installed, any MCP-aware agent can also save **web pages, AI chat shares, and pasted text** into your memex memory — searchable from any other AI chat later. In Claude Code, Cursor, Cline, …:

package/README.ru.md

@@ -143,10 +143,12 @@ curl -fsSL https://raw.githubusercontent.com/parallelclaw/memex-mvp/main/skills/
 ```bash
 memex search "Postgres миграция"            # полнотекстовый поиск
 memex search "Q2 deck" --chat "Memex Bot"   # сузить до конкретного чата по title
+memex search "JWT" --as-of 2026-05-01       # v0.8.1: time-travel — только до даты
+memex when "Brian Chesky"                    # v0.8.1: «когда мы это обсуждали» — даты + чаты
 memex recent --limit 5                       # последние 5 сообщений из всех источников
 memex list --source web                      # все сохранённые URL'ы
 memex get web-1582ab51a7b7                   # полный контент одной conversation
-memex overview                               # snapshot корпуса
+memex overview                               # snapshot корпуса + v0.8.1: capture streak
 memex projects                               # уникальные project_paths
 memex help                                   # полное руководство (HELP.md)
 memex --help                                 # справка по командам
@@ -162,6 +164,26 @@ memex --help                                 # справка по команд
 - Хочешь пайпить результаты: `memex search foo --json | jq ...`
 - Хочешь сдампить полный transcript в stdout для context'a
 
+### Auto-context (v0.8+) — Claude уже знает что ты делал
+
+После `memex-sync install` появляется промпт про **auto-context**. Если согласишься — memex добавит SessionStart хук в `~/.claude/settings.json`. Когда ты потом открываешь Claude Code в каком-то проекте, Claude **сам подгружает 500-1500 токенов контекста** про этот проект — что ты делал недавно, какие conversations его касались, какие связанные темы всплывали. Никаких вопросов, никаких tool-call'ов, просто Claude **знает**.
+
+```bash
+# Добавить/удалить хук вне install-flow:
+memex hook install        # добавить SessionStart хук (idempotent)
+memex hook uninstall      # удалить только memex-запись, остальные хуки не трогает
+memex hook status         # показать текущее состояние
+
+# Посмотреть что будет инжектиться:
+memex context             # dry-run для текущей директории
+memex context --pwd /path # для другого проекта
+memex context --no-source telegram  # исключить источник
+```
+
+Хук **сохраняет существующие хуки** (gstack, твои кастомные) — добавляет только свою запись.
+
+**Сейчас native SessionStart есть только в Claude Code.** Для Cursor / Cline / Continue / Zed fallback через MCP-tool — в roadmap v0.9.0.
+
 ### Подключение к Claude Code
 
 Сначала возьми **два абсолютных пути** в терминале:

package/ingest.js

@@ -61,6 +61,8 @@ import {
   vaultSlug,
   shouldSkipPath,
 } from './lib/parse-obsidian.js';
+import { installHook as installSessionStartHook } from './lib/hook/install.js';
+import { createInterface } from 'node:readline';
 import {
   CONFIG_PATH,
   KNOWN_SOURCES,
@@ -137,7 +139,12 @@ if (subcommand && subcommand !== '--help' && subcommand.startsWith('-') === fals
     console.error(`usage: memex-sync [install|uninstall|status|logs|serve]`);
     process.exit(2);
   }
-  handler();
+  // Handlers may be sync (most) or async (cmdInstall after v0.8 — needs readline
+  // for the auto-context prompt). Promise.resolve() normalises both.
+  Promise.resolve(handler()).catch((e) => {
+    console.error(`error in ${subcommand}: ${e.stack || e.message}`);
+    process.exit(1);
+  });
   // CLI handlers either exit themselves or fall through to daemon mode (cmdServe)
 } else if (subcommand === '--help' || subcommand === '-h') {
   console.log(`memex-sync — auto-capture daemon for memex memory
@@ -185,7 +192,7 @@ paths:
 
 // -------------------- CLI command handlers --------------------
 
-function cmdInstall() {
+async function cmdInstall() {
   if (platform() !== 'darwin') {
     console.error('install: macOS-only for now (LaunchAgent). Linux systemd-user support pending.');
     console.error('on Linux you can run: nohup memex-sync &');
@@ -243,6 +250,18 @@ function cmdInstall() {
   console.log(`  log:   ${LOG_PATH}`);
   console.log('');
 
+  // ── Auto-context prompt (v0.8+) ─────────────────────────────────────
+  // Bundle Claude Code SessionStart hook install into the same flow
+  // the user is already running. Single [Y/n] beats a separate command
+  // they'd never remember.
+  //
+  // Honor non-interactive flags / env for CI:
+  //   --auto-context yes    explicit opt-in
+  //   --auto-context no     explicit opt-out
+  //   --yes / -y            accept all defaults (yes)
+  //   $MEMEX_AUTO_CONTEXT=yes|no   env override
+  await maybeInstallAutoContextHook();
+
   // Show what daemon will actually capture, based on current config.
   const cfg = loadConfig();
   console.log('memex-sync will capture from these sources:');
@@ -277,6 +296,97 @@ function cmdInstall() {
   process.exit(0);
 }
 
+// ──────────────────────────────────────────────────────────────────
+// Auto-context hook prompt — bundled into `memex-sync install` so the
+// user doesn't need to remember an extra `memex hook install` step.
+//
+// Decision priority:
+//   1. CLI flag --auto-context=yes|no  (explicit)
+//   2. CLI flag --yes / -y             (accept all defaults: yes)
+//   3. env MEMEX_AUTO_CONTEXT=yes|no    (for CI / scripts)
+//   4. Interactive [Y/n] prompt        (TTY only)
+//   5. Default: SKIP if no TTY (don't hang on stdin in non-TTY contexts)
+async function maybeInstallAutoContextHook() {
+  const argv = process.argv.slice(3); // drop ["node", "ingest.js", "install"]
+
+  // Parse flags
+  let explicit = null; // 'yes' | 'no' | null
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--auto-context') {
+      const v = (argv[++i] || '').toLowerCase();
+      if (v === 'yes' || v === 'y' || v === 'true') explicit = 'yes';
+      else if (v === 'no' || v === 'n' || v === 'false') explicit = 'no';
+    } else if (a === '--auto-context=yes') explicit = 'yes';
+    else if (a === '--auto-context=no') explicit = 'no';
+    else if (a === '--yes' || a === '-y') explicit = 'yes';
+  }
+
+  // Env fallback
+  if (explicit === null) {
+    const env = (process.env.MEMEX_AUTO_CONTEXT || '').toLowerCase();
+    if (env === 'yes' || env === 'y' || env === 'true' || env === '1') explicit = 'yes';
+    else if (env === 'no' || env === 'n' || env === 'false' || env === '0') explicit = 'no';
+  }
+
+  // Interactive prompt as last resort
+  if (explicit === null) {
+    if (!process.stdin.isTTY) {
+      // Non-interactive (CI, scripts, install-skill flows that don't pipe stdin):
+      // skip silently. User can run `memex hook install` later.
+      console.log('Auto-context hook: skipped (non-interactive). Enable with: memex hook install');
+      console.log('');
+      return;
+    }
+    explicit = await promptYesNo(
+      `Auto-context (Brian Chesky mode):\n` +
+      `  When you open Claude Code in a project, memex can inject 500-1500 tokens\n` +
+      `  of relevant context so Claude knows what you were doing — without you\n` +
+      `  having to ask. Adds a SessionStart hook to ~/.claude/settings.json.\n` +
+      `  Other hooks (e.g. gstack) are preserved.\n\n` +
+      `  Enable?`,
+      'yes' // default Y
+    );
+  }
+
+  if (explicit !== 'yes') {
+    console.log('Auto-context hook: skipped. Enable later with: memex hook install');
+    console.log('');
+    return;
+  }
+
+  const r = installSessionStartHook();
+  if (r.error) {
+    console.log(`Auto-context hook: ✗ ${r.error}`);
+    console.log('  (memex-sync daemon still works — only the auto-context hook failed)');
+    console.log('');
+    return;
+  }
+  if (r.alreadyPresent) {
+    console.log('Auto-context hook: already installed (no-op).');
+  } else {
+    console.log('Auto-context hook: ✓ installed.');
+    console.log(`  settings: ${r.settingsPath}`);
+    console.log(`  command:  ${r.command}`);
+    console.log('  Restart Claude Code (Cmd+Q + reopen) to activate.');
+  }
+  console.log('');
+}
+
+function promptYesNo(question, defaultAnswer) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const suffix = defaultAnswer === 'yes' ? ' [Y/n] ' : ' [y/N] ';
+    rl.question(question + suffix, (answer) => {
+      rl.close();
+      const v = (answer || '').trim().toLowerCase();
+      if (v === 'y' || v === 'yes') resolve('yes');
+      else if (v === 'n' || v === 'no') resolve('no');
+      else resolve(defaultAnswer); // empty enter → default
+    });
+  });
+}
+
 function cmdUninstall() {
   if (platform() !== 'darwin') {
     console.error('uninstall: macOS-only for now.');

package/lib/cli/index.js

@@ -24,15 +24,22 @@
  */
 
 import Database from 'better-sqlite3';
-import { join } from 'node:path';
+import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
+import {
+  installHook,
+  uninstallHook,
+  getHookStatus,
+  resolveMemexBinPath,
+} from '../hook/install.js';
 
 // ---------- Subcommand registry ----------
 export const CLI_SUBCOMMAND_NAMES = [
   'search', 'recent', 'list', 'get', 'overview',
-  'projects', 'help', '-h', '--help', '-v', '--version',
+  'projects', 'context', 'hook', 'when',
+  'help', '-h', '--help', '-v', '--version',
 ];
 
 // ---------- Path helpers ----------
@@ -71,6 +78,15 @@ function parseArgs(argv) {
     else if (a === '--project') opts.project = argv[++i];
     else if (a === '--sort') opts.sort = argv[++i];
     else if (a === '--include-archived') opts.includeArchived = true;
+    else if (a === '--pwd') opts.pwd = argv[++i];
+    else if (a === '--budget' || a === '--budget-tokens') opts.budget = parseInt(argv[++i], 10);
+    else if (a === '--freshness-days') opts.freshnessDays = parseInt(argv[++i], 10);
+    else if (a === '--no-source') {
+      // Allow repeated --no-source telegram --no-source obsidian
+      if (!Array.isArray(opts.noSource)) opts.noSource = [];
+      opts.noSource.push(argv[++i]);
+    }
+    else if (a === '--as-of') opts.asOf = argv[++i];
     else if (a === '--help' || a === '-h') opts.help = true;
     else if (a.startsWith('--')) { /* ignore unknown flag for forward-compat */ }
     else positionals.push(a);
@@ -98,6 +114,20 @@ function fmtDateTime(ts) {
   return new Date(ts * 1000).toISOString().slice(0, 16).replace('T', ' ');
 }
 
+/**
+ * Parse YYYY-MM-DD into unix timestamp at start-of-day (00:00 UTC).
+ * Returns null on invalid input.
+ */
+function parseAsOf(s) {
+  if (typeof s !== 'string') return null;
+  const m = s.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+  if (!m) return null;
+  const [, y, mo, d] = m;
+  const date = new Date(`${y}-${mo}-${d}T00:00:00Z`);
+  if (isNaN(date.getTime())) return null;
+  return Math.floor(date.getTime() / 1000);
+}
+
 // FTS5 expects sanitized tokens — strip what would be operators
 function sanitizeFtsQuery(q) {
   return String(q || '')
@@ -142,6 +172,18 @@ async function cmdSearch(args) {
     filters.push('LOWER(c.title) LIKE LOWER(?)');
     params.push(`%${opts.chat}%`);
   }
+  // Time-travel: --as-of YYYY-MM-DD returns only messages with ts strictly
+  // before that calendar date (start-of-day). Useful for retrospectives:
+  // "what did I know about X two weeks ago?"
+  if (opts.asOf) {
+    const cutoff = parseAsOf(opts.asOf);
+    if (cutoff === null) {
+      console.error(`Invalid --as-of date: "${opts.asOf}". Expected YYYY-MM-DD.`);
+      process.exit(2);
+    }
+    filters.push('m.ts > 0 AND m.ts < ?');
+    params.push(cutoff);
+  }
 
   let orderBy;
   if (opts.sort === 'date_asc') {
@@ -345,6 +387,10 @@ async function cmdOverview(args) {
   ORDER BY last_ts DESC
      LIMIT 10
   `).all();
+
+  // Streak + today's capture count (D6 — GitHub-style daily habit signal)
+  const streak = computeStreak(db);
+
   db.close();
 
   if (opts.json) {
@@ -353,11 +399,25 @@ async function cmdOverview(args) {
       total_conversations: totalConvs,
       sources,
       recent_conversations: recentConvs,
+      streak: streak,
     }, null, 2));
     return;
   }
   console.log(c.bold('memex corpus snapshot') + '\n');
   console.log(`Total: ${c.green(totalMsgs + ' messages')} in ${c.green(totalConvs + ' conversations')}\n`);
+
+  // Streak block — only show if there's at least one captured day
+  if (streak.streakDays > 0) {
+    const today = streak.todayMessages;
+    const todayLine = today > 0
+      ? `Today: ${c.green(today + ' messages')} across ${streak.todayConversations} conversation(s).`
+      : `${c.dim('No captures yet today.')}`;
+    const streakLine = streak.streakDays >= 2
+      ? `${c.green('✓ ' + streak.streakDays + '-day capture streak')} (since ${fmtDate(streak.streakStartTs)}). ${todayLine}`
+      : `${c.dim('Starting fresh — capture something today to begin a streak.')} ${todayLine}`;
+    console.log(streakLine + '\n');
+  }
+
   console.log(c.bold('By source:'));
   for (const s of sources) {
     console.log(`  ${s.source.padEnd(18)} ${String(s.msgs).padStart(7)} msgs · ${String(s.chats).padStart(5)} chats · ${fmtDate(s.first_ts)} → ${fmtDate(s.last_ts)}`);
@@ -369,6 +429,66 @@ async function cmdOverview(args) {
   }
 }
 
+/**
+ * Compute current capture streak: consecutive days (working backward from
+ * today) with at least one message captured.
+ *
+ * Returns:
+ *   {
+ *     streakDays:      number,   // 0 if today has 0 captures
+ *     streakStartTs:   number,   // ts of the earliest day in the streak
+ *     todayMessages:   number,   // count of messages captured today
+ *     todayConversations: number,
+ *   }
+ *
+ * "Day" boundaries are UTC (matches how we store ts). A more user-friendly
+ * version would use local-day, but UTC is consistent and predictable —
+ * good enough for v0.8.1.
+ */
+function computeStreak(db) {
+  const now = Math.floor(Date.now() / 1000);
+  const todayStart = Math.floor(now / 86400) * 86400; // UTC midnight today
+
+  // Distinct days with captures, sorted desc — pull up to ~365 days to bound work
+  const days = db.prepare(`
+    SELECT DISTINCT (ts / 86400) AS day
+      FROM messages
+     WHERE ts >= ?
+  ORDER BY day DESC
+  `).all(todayStart - 365 * 86400);
+
+  let streakDays = 0;
+  let streakStartTs = 0;
+  if (days.length > 0) {
+    const todayDay = Math.floor(todayStart / 86400);
+    let cursor = todayDay;
+    for (const row of days) {
+      if (row.day === cursor) {
+        streakDays += 1;
+        streakStartTs = row.day * 86400;
+        cursor -= 1;
+      } else if (row.day < cursor) {
+        // Streak broken — stop
+        break;
+      }
+      // row.day > cursor shouldn't happen with DESC order; if it does, skip
+    }
+  }
+
+  const todayRow = db.prepare(`
+    SELECT COUNT(*) AS msgs, COUNT(DISTINCT conversation_id) AS convs
+      FROM messages
+     WHERE ts >= ?
+  `).get(todayStart);
+
+  return {
+    streakDays,
+    streakStartTs,
+    todayMessages: todayRow.msgs,
+    todayConversations: todayRow.convs,
+  };
+}
+
 // =============================================================
 // PROJECTS
 // =============================================================
@@ -400,6 +520,348 @@ async function cmdProjects(args) {
   }
 }
 
+// =============================================================
+// WHEN — chronological "when did we talk about X" CLI shortcut
+// =============================================================
+//
+// `memex when "JWT decision"` answers the single most common memex query
+// in 1 second: dates, sources, conversation titles. No snippets, no
+// re-ranking — just chronological recall.
+//
+// Returns one row per matching conversation, sorted by latest message in
+// that conversation (date_desc). Useful when the user remembers a topic
+// but can't recall WHICH session it came from or WHEN.
+async function cmdWhen(args) {
+  const { opts, positionals } = parseArgs(args);
+  const query = positionals.join(' ').trim();
+
+  if (!query || opts.help) {
+    console.error('Usage: memex when "<query>" [--source X] [--limit N] [--json]');
+    console.error('');
+    console.error('Returns a chronological "when did we talk about X" list — date + source +');
+    console.error('conversation title, no snippets. Sorted newest first.');
+    process.exit(query ? 0 : 2);
+  }
+
+  const limit = Math.min(50, Math.max(1, opts.limit || 15));
+  const sanitized = sanitizeFtsQuery(query);
+  if (!sanitized) {
+    console.error('Query became empty after sanitization — try simpler keywords.');
+    process.exit(2);
+  }
+
+  const filters = ['messages_fts MATCH ?'];
+  const params = [sanitized];
+  if (opts.source) {
+    filters.push('m.source = ?');
+    params.push(opts.source);
+  }
+  if (!opts.includeArchived) {
+    filters.push('(c.archived_at IS NULL OR c.archived_at = 0)');
+  }
+
+  // Aggregate by conversation: one row per chat, latest hit's date, match count
+  const sql = `
+    SELECT m.conversation_id,
+           m.source,
+           MAX(m.ts) AS latest_ts,
+           MIN(m.ts) AS earliest_ts,
+           COUNT(*)  AS match_count,
+           c.title AS conversation_title
+      FROM messages_fts
+      JOIN messages m ON m.id = messages_fts.rowid
+ LEFT JOIN conversations c ON c.conversation_id = m.conversation_id
+     WHERE ${filters.join(' AND ')}
+  GROUP BY m.conversation_id
+  ORDER BY latest_ts DESC
+     LIMIT ?
+  `;
+  const db = openDb();
+  const rows = db.prepare(sql).all(...params, limit);
+  db.close();
+
+  if (opts.json) {
+    console.log(JSON.stringify({ query, count: rows.length, results: rows }, null, 2));
+    return;
+  }
+  if (rows.length === 0) {
+    console.log(`No mentions of ${c.bold('"' + query + '"')} found.`);
+    return;
+  }
+  console.log(`${c.bold('"' + query + '"')} mentioned in ${c.bold(rows.length)} conversation(s):\n`);
+  for (const r of rows) {
+    const date = fmtDate(r.latest_ts);
+    const range = r.earliest_ts && r.earliest_ts !== r.latest_ts
+      ? ` (also ${fmtDate(r.earliest_ts)})`
+      : '';
+    const count = r.match_count > 1 ? ` · ${r.match_count} matches` : '';
+    console.log(`  ${c.green(date)}${c.dim(range)}  ${c.dim(r.source.padEnd(14))}  ${c.cyan((r.conversation_title || r.conversation_id).slice(0, 60))}${c.dim(count)}`);
+  }
+  console.log('');
+  console.log(c.dim(`To read one: memex get <conversation_id>  |  to search content: memex search "${query}"`));
+}
+
+// =============================================================
+// CONTEXT — output relevant memex context for current pwd
+// =============================================================
+//
+// Designed to be called by Claude Code SessionStart hook (or equivalent).
+// stdout markdown becomes a system message injected into Claude's context
+// BEFORE the user sends their first prompt. So Claude "knows" what the
+// user has been doing in this project without being asked.
+//
+// Smart selection:
+//   1. Direct project_path match — conversations where this exact path was
+//      captured (Claude Code/Cowork cwd, Obsidian vault, etc.)
+//   2. Project-name fuzzy match — conversations whose title mentions the
+//      basename of pwd (catches discussions of the project across sources
+//      like Telegram where there's no project_path).
+//
+// Default budget: 1500 tokens (≈6000 chars markdown). Truncated cleanly
+// if needed — never spill into Claude's context window unboundedly.
+//
+// Privacy: telegram source is included by default (users discussed feature
+// idea here) but can be excluded via --no-source telegram. Future:
+// per-source sensitivity flags in ~/.memex/config.json.
+//
+// Output is markdown. --json gives the structured underlying data.
+async function cmdContext(args) {
+  const { opts } = parseArgs(args);
+
+  if (opts.help) {
+    console.error('Usage: memex context [--pwd PATH] [--limit N] [--budget-tokens N] [--freshness-days N] [--no-source NAME] [--json]');
+    console.error('');
+    console.error('Outputs markdown summarizing recent memex activity relevant to the current pwd.');
+    console.error('Designed for use as a Claude Code SessionStart hook.');
+    process.exit(0);
+  }
+
+  const pwd = opts.pwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const limit = Math.min(20, Math.max(1, opts.limit || 5));
+  const tokenBudget = Math.min(8000, Math.max(50, opts.budget || 1500));
+  const freshnessDays = Math.min(365, Math.max(1, opts.freshnessDays || 90));
+  const excludeSources = Array.isArray(opts.noSource) ? opts.noSource : (opts.noSource ? [opts.noSource] : []);
+
+  const project = basename(pwd);
+  const sinceTs = Math.floor(Date.now() / 1000) - freshnessDays * 86400;
+
+  const db = openDb();
+
+  // 1. Direct project_path matches — highest signal.
+  const directFilters = [
+    'project_path LIKE ?',
+    'last_ts >= ?',
+    '(archived_at IS NULL OR archived_at = 0)',
+  ];
+  const directParams = [`%${pwd}%`, sinceTs];
+  if (excludeSources.length) {
+    const placeholders = excludeSources.map(() => '?').join(',');
+    directFilters.push(`source NOT IN (${placeholders})`);
+    directParams.push(...excludeSources);
+  }
+  const directConvs = db.prepare(`
+    SELECT conversation_id, source, title, first_ts, last_ts, message_count
+      FROM conversations
+     WHERE ${directFilters.join(' AND ')}
+  ORDER BY last_ts DESC
+     LIMIT ?
+  `).all(...directParams, limit);
+
+  // 2. Fuzzy project-name matches in title (catches Telegram / web discussion of project).
+  // Skip duplicates we already got from direct match.
+  const seenIds = new Set(directConvs.map((c) => c.conversation_id));
+  const fuzzyFilters = [
+    'LOWER(title) LIKE LOWER(?)',
+    'last_ts >= ?',
+    '(archived_at IS NULL OR archived_at = 0)',
+  ];
+  const fuzzyParams = [`%${project}%`, sinceTs];
+  if (excludeSources.length) {
+    const placeholders = excludeSources.map(() => '?').join(',');
+    fuzzyFilters.push(`source NOT IN (${placeholders})`);
+    fuzzyParams.push(...excludeSources);
+  }
+  const fuzzyConvs = db.prepare(`
+    SELECT conversation_id, source, title, first_ts, last_ts, message_count
+      FROM conversations
+     WHERE ${fuzzyFilters.join(' AND ')}
+  ORDER BY last_ts DESC
+     LIMIT ?
+  `).all(...fuzzyParams, limit * 2);
+  const filteredFuzzy = fuzzyConvs.filter((r) => !seenIds.has(r.conversation_id)).slice(0, Math.max(1, limit - directConvs.length));
+
+  db.close();
+
+  const all = [...directConvs, ...filteredFuzzy];
+
+  if (opts.json) {
+    console.log(JSON.stringify({
+      pwd, project, freshness_days: freshnessDays,
+      direct_matches: directConvs.length,
+      fuzzy_matches: filteredFuzzy.length,
+      conversations: all,
+      token_budget: tokenBudget,
+    }, null, 2));
+    return;
+  }
+
+  // Markdown output (TTY-color stripped — this is consumed by Claude, not the user)
+  const lines = [];
+  lines.push(`## memex auto-context for ${project}`);
+  lines.push('');
+
+  if (all.length === 0) {
+    lines.push(`_No recent activity in memex for this project (last ${freshnessDays} days)._`);
+    lines.push('');
+    lines.push(`Path searched: \`${pwd}\``);
+    lines.push('');
+    lines.push('---');
+    lines.push(`_memex auto-context · empty · v0.8+_`);
+    process.stdout.write(lines.join('\n') + '\n');
+    return;
+  }
+
+  if (directConvs.length > 0) {
+    lines.push(`### Recent conversations in this project (last ${freshnessDays} days)`);
+    lines.push('');
+    for (const conv of directConvs) {
+      const date = fmtDate(conv.last_ts);
+      const title = (conv.title || conv.conversation_id).slice(0, 100);
+      lines.push(`- **${date}** · _${conv.source}_ · ${title} (${conv.message_count} msgs)`);
+    }
+    lines.push('');
+  }
+
+  if (filteredFuzzy.length > 0) {
+    lines.push(`### Related discussions mentioning "${project}"`);
+    lines.push('');
+    for (const conv of filteredFuzzy) {
+      const date = fmtDate(conv.last_ts);
+      const title = (conv.title || conv.conversation_id).slice(0, 100);
+      lines.push(`- **${date}** · _${conv.source}_ · ${title}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('---');
+  lines.push(`_memex auto-context · ${all.length} sources · v0.8+_`);
+  lines.push(`_To search deeper, ask memex (via MCP tool or terminal: \`memex search "..."\`)._`);
+
+  let out = lines.join('\n') + '\n';
+
+  // Token budget enforcement — rough estimate ≈ 4 chars/token. Truncate
+  // cleanly at a line boundary to keep markdown valid.
+  const maxChars = tokenBudget * 4;
+  if (out.length > maxChars) {
+    out = out.slice(0, maxChars);
+    const lastNewline = out.lastIndexOf('\n');
+    if (lastNewline > 0) out = out.slice(0, lastNewline);
+    out += '\n\n_[context truncated — exceeds token budget]_\n';
+  }
+
+  process.stdout.write(out);
+}
+
+// =============================================================
+// HOOK — install/uninstall/status for Claude Code SessionStart
+// =============================================================
+async function cmdHook(args) {
+  const sub = args[0];
+  const rest = args.slice(1);
+  const { opts } = parseArgs(rest);
+
+  if (!sub || sub === '--help' || sub === '-h') {
+    console.error('Usage: memex hook <install|uninstall|status>');
+    console.error('');
+    console.error('  install    Add memex SessionStart hook to ~/.claude/settings.json');
+    console.error('             Idempotent — re-runs are no-ops.');
+    console.error('             Claude Code will inject memex context on every new session.');
+    console.error('');
+    console.error('  uninstall  Remove the memex hook entry. Preserves all other hooks.');
+    console.error('');
+    console.error('  status     Show whether the hook is currently installed.');
+    process.exit(sub ? 0 : 2);
+  }
+
+  if (sub === 'install') {
+    const r = installHook();
+    if (opts.json) {
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    if (r.error) {
+      console.error(`✗ ${r.error}`);
+      process.exit(1);
+    }
+    if (r.alreadyPresent) {
+      console.log(`✓ memex hook already installed in ${r.settingsPath}`);
+      console.log(`  command: ${r.command}`);
+      return;
+    }
+    console.log(`✓ memex SessionStart hook installed`);
+    console.log(`  settings: ${r.settingsPath}`);
+    console.log(`  command:  ${r.command}`);
+    console.log('');
+    console.log('Restart Claude Code (Cmd+Q + reopen) for the hook to activate.');
+    console.log('After restart, Claude will see memex context on every new session.');
+    console.log('');
+    console.log('Disable later: memex hook uninstall');
+    return;
+  }
+
+  if (sub === 'uninstall') {
+    const r = uninstallHook();
+    if (opts.json) {
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    if (r.error) {
+      console.error(`✗ ${r.error}`);
+      process.exit(1);
+    }
+    if (!r.wasPresent) {
+      console.log('memex hook was not installed (nothing to remove).');
+      return;
+    }
+    console.log('✓ memex SessionStart hook removed');
+    console.log('  Other hooks in ~/.claude/settings.json preserved.');
+    console.log('');
+    console.log('Restart Claude Code (Cmd+Q + reopen) for the change to take effect.');
+    return;
+  }
+
+  if (sub === 'status') {
+    const r = getHookStatus();
+    if (opts.json) {
+      console.log(JSON.stringify(r, null, 2));
+      return;
+    }
+    console.log(`settings file: ${r.settingsPath}`);
+    if (!r.settingsExists) {
+      console.log('  status: file does not exist');
+      console.log('  hook:   NOT installed');
+      return;
+    }
+    if (!r.settingsValid) {
+      console.log('  status: file exists but is not valid JSON');
+      console.log('  hook:   could not determine (fix settings file first)');
+      return;
+    }
+    console.log(`  hook:   ${r.installed ? 'INSTALLED' : 'NOT installed'}`);
+    if (r.installed) console.log(`  command: ${r.command}`);
+    console.log(`  other SessionStart hooks: ${r.otherSessionStartHooks}`);
+    if (!r.installed) {
+      console.log('');
+      console.log('Install with: memex hook install');
+    }
+    return;
+  }
+
+  console.error(`Unknown hook subcommand: ${sub}`);
+  console.error('Run "memex hook --help" for usage.');
+  process.exit(2);
+}
+
 // =============================================================
 // HELP — print HELP.md content
 // =============================================================
@@ -430,9 +892,16 @@ COMMANDS
     --chat "<title>"             filter by conversation title (substring)
     --project <path>             filter by project_path (substring)
     --sort <mode>                relevance | date_asc | date_desc
+    --as-of YYYY-MM-DD           time-travel: only messages before this date
     --limit N                    max results (default 10, max 50)
     --json                       output JSON instead of markdown
 
+  when "<query>"                 chronological "when did we talk about X" —
+                                 one row per conversation, date + title, no snippets
+    --source <name>              filter by source
+    --limit N                    default 15, max 50
+    --json
+
   recent                         most recent messages across all sources
     --limit N                    default 20, max 100
     --source <name>              filter by source
@@ -454,6 +923,21 @@ COMMANDS
     --limit N                    default 50, max 500
     --json
 
+  context                        output markdown summary of recent activity
+                                 in current pwd (for Claude Code SessionStart
+                                 hook — auto-injects context into new sessions)
+    --pwd PATH                   override (default: $CLAUDE_PROJECT_DIR or cwd)
+    --limit N                    max conversations to include (default 5)
+    --budget-tokens N            cap output size (default 1500)
+    --freshness-days N           only conversations newer than (default 90)
+    --no-source NAME             exclude a source (repeatable; e.g. telegram)
+    --json
+
+  hook install                   install SessionStart hook in
+                                 ~/.claude/settings.json (idempotent)
+  hook uninstall                 remove only the memex hook entry
+  hook status                    show whether the hook is installed
+
   help                           print the user guide (HELP.md)
   --help, -h                     this command reference
   --version, -v                  print package version
@@ -500,6 +984,9 @@ export async function runCli(sub, args) {
     case 'get':        return cmdGet(args);
     case 'overview':   return cmdOverview(args);
     case 'projects':   return cmdProjects(args);
+    case 'when':       return cmdWhen(args);
+    case 'context':    return cmdContext(args);
+    case 'hook':       return cmdHook(args);
     case 'help':       return cmdHelp();
     case '--help':
     case '-h':         return cmdUsage();

package/lib/hook/install.js

@@ -0,0 +1,268 @@
+/**
+ * Claude Code SessionStart hook installer for memex auto-context.
+ *
+ * When the user opens a new Claude Code session, Claude Code looks at
+ * ~/.claude/settings.json for `hooks.SessionStart` entries and runs each
+ * command before showing the user the first prompt. The stdout of those
+ * commands gets injected into Claude's context as a system message.
+ *
+ * Memex's hook calls `memex context` which outputs a markdown summary of
+ * recent memex activity relevant to the current pwd. End result: Claude
+ * "knows" what you were doing in this project without you having to ask.
+ *
+ * Idempotency: install operations are safe to re-run. We detect our entry
+ * by command-string match — if any SessionStart hook command starts with
+ * MEMEX_COMMAND_MARKER, we treat it as ours and don't add another.
+ *
+ * Atomicity: we always write to a .tmp file first, then rename. Never
+ * touch the user's existing hooks for other tools.
+ *
+ * Cross-client: only Claude Code and OpenClaw have SessionStart natively.
+ * For Cursor/Cline/Continue/Zed, fallback strategies (MCP resource, skills,
+ * system prompt) are tracked separately — not part of this module.
+ */
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import {
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  existsSync,
+  mkdirSync,
+} from 'node:fs';
+import { execSync } from 'node:child_process';
+
+const HOME = homedir();
+const CLAUDE_DIR = join(HOME, '.claude');
+const SETTINGS_PATH = join(CLAUDE_DIR, 'settings.json');
+
+// Command marker — every memex hook command starts with this. Used to
+// detect our own entry for idempotency / uninstall, without collision
+// risk against other tools' hooks (gstack, custom user hooks, etc.).
+const MEMEX_COMMAND_MARKER = 'memex context';
+
+/**
+ * Returns the absolute path to the `memex` binary that should be used in
+ * the hook command. Tries multiple strategies in order:
+ *   1. `which memex` (npm-global install)
+ *   2. process.execPath + this module's known location (current invocation)
+ *   3. fallback to bare "memex" (relies on PATH at hook execution time)
+ *
+ * Returns the resolved path string.
+ */
+export function resolveMemexBinPath() {
+  try {
+    const which = execSync('which memex', { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    if (which && existsSync(which)) return which;
+  } catch (_) {}
+  // Fallback: rely on PATH at hook-execution time. Claude Code loads
+  // user shell environment for hooks, so PATH usually works.
+  return 'memex';
+}
+
+/**
+ * Read ~/.claude/settings.json safely. Returns:
+ *   { exists: bool, valid: bool, data: object, raw: string|null }
+ */
+export function readSettings() {
+  if (!existsSync(SETTINGS_PATH)) {
+    return { exists: false, valid: true, data: {}, raw: null };
+  }
+  try {
+    const raw = readFileSync(SETTINGS_PATH, 'utf-8');
+    const data = JSON.parse(raw);
+    return { exists: true, valid: true, data, raw };
+  } catch (e) {
+    return {
+      exists: true,
+      valid: false,
+      data: {},
+      raw: null,
+      error: e.message,
+    };
+  }
+}
+
+/**
+ * Find our memex SessionStart hook entry in the parsed settings.
+ * Returns { found: bool, index: number, command: string|null }.
+ *
+ * Claude Code's hooks schema (as of 2026):
+ *   settings.hooks.SessionStart = [
+ *     { matcher: "...", hooks: [{ type: "command", command: "..." }] }
+ *   ]
+ *
+ * We treat an outer entry as "ours" if any of its inner hooks has a
+ * command string containing MEMEX_COMMAND_MARKER.
+ */
+export function findMemexHookEntry(settings) {
+  const sessionStart = settings?.hooks?.SessionStart;
+  if (!Array.isArray(sessionStart)) {
+    return { found: false, index: -1, command: null };
+  }
+  for (let i = 0; i < sessionStart.length; i++) {
+    const entry = sessionStart[i];
+    const inner = entry?.hooks;
+    if (!Array.isArray(inner)) continue;
+    for (const h of inner) {
+      if (typeof h?.command === 'string' && h.command.includes(MEMEX_COMMAND_MARKER)) {
+        return { found: true, index: i, command: h.command };
+      }
+    }
+  }
+  return { found: false, index: -1, command: null };
+}
+
+/**
+ * Add the memex SessionStart hook entry to ~/.claude/settings.json.
+ *
+ * Idempotent: if a memex entry already exists, no-op (returns
+ * alreadyPresent: true). If the user has OTHER SessionStart hooks (e.g.
+ * from gstack), they are preserved untouched — we only append our entry
+ * to the array.
+ *
+ * Returns:
+ *   { installed: bool, alreadyPresent: bool, settingsPath: str,
+ *     command: str, error: str|null }
+ */
+export function installHook(opts = {}) {
+  const binPath = opts.binPath || resolveMemexBinPath();
+  const command = `${binPath} context`;
+
+  const settings = readSettings();
+  if (settings.exists && !settings.valid) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      settingsPath: SETTINGS_PATH,
+      command,
+      error: `Could not parse ${SETTINGS_PATH}: ${settings.error}. Fix the file manually first.`,
+    };
+  }
+
+  const data = settings.data || {};
+  const existing = findMemexHookEntry(data);
+  if (existing.found) {
+    return {
+      installed: false,
+      alreadyPresent: true,
+      settingsPath: SETTINGS_PATH,
+      command: existing.command,
+      error: null,
+    };
+  }
+
+  // Build our entry. Use ".*" matcher (match any session) and the standard
+  // {type: "command", command: ...} inner hook shape.
+  const memexEntry = {
+    matcher: '.*',
+    hooks: [{ type: 'command', command }],
+  };
+
+  // Defensive nested-set: never clobber adjacent keys
+  if (!data.hooks) data.hooks = {};
+  if (!Array.isArray(data.hooks.SessionStart)) data.hooks.SessionStart = [];
+  data.hooks.SessionStart.push(memexEntry);
+
+  // Atomic write — temp file + rename
+  try {
+    mkdirSync(CLAUDE_DIR, { recursive: true });
+    const tmpPath = SETTINGS_PATH + '.tmp';
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    renameSync(tmpPath, SETTINGS_PATH);
+  } catch (e) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      settingsPath: SETTINGS_PATH,
+      command,
+      error: `Failed to write ${SETTINGS_PATH}: ${e.message}`,
+    };
+  }
+
+  return {
+    installed: true,
+    alreadyPresent: false,
+    settingsPath: SETTINGS_PATH,
+    command,
+    error: null,
+  };
+}
+
+/**
+ * Remove the memex SessionStart hook entry. Preserves all other hooks.
+ *
+ * Returns: { removed: bool, wasPresent: bool, error: str|null }
+ */
+export function uninstallHook() {
+  const settings = readSettings();
+  if (!settings.exists) {
+    return { removed: false, wasPresent: false, error: null };
+  }
+  if (!settings.valid) {
+    return {
+      removed: false,
+      wasPresent: false,
+      error: `Could not parse ${SETTINGS_PATH}: ${settings.error}`,
+    };
+  }
+
+  const data = settings.data;
+  const existing = findMemexHookEntry(data);
+  if (!existing.found) {
+    return { removed: false, wasPresent: false, error: null };
+  }
+
+  // Remove our entry from the SessionStart array
+  data.hooks.SessionStart.splice(existing.index, 1);
+
+  // Cleanup empty containers — don't leave behind `hooks: {SessionStart: []}`
+  // detritus if memex was the only hook.
+  if (data.hooks.SessionStart.length === 0) delete data.hooks.SessionStart;
+  if (data.hooks && Object.keys(data.hooks).length === 0) delete data.hooks;
+
+  try {
+    const tmpPath = SETTINGS_PATH + '.tmp';
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    renameSync(tmpPath, SETTINGS_PATH);
+  } catch (e) {
+    return {
+      removed: false,
+      wasPresent: true,
+      error: `Failed to write ${SETTINGS_PATH}: ${e.message}`,
+    };
+  }
+
+  return { removed: true, wasPresent: true, error: null };
+}
+
+/**
+ * Inspect current hook status. Returns:
+ *   { installed: bool, settingsPath: str, command: str|null,
+ *     otherSessionStartHooks: number, settingsExists: bool,
+ *     settingsValid: bool }
+ */
+export function getHookStatus() {
+  const settings = readSettings();
+  const result = {
+    installed: false,
+    settingsPath: SETTINGS_PATH,
+    command: null,
+    otherSessionStartHooks: 0,
+    settingsExists: settings.exists,
+    settingsValid: settings.valid,
+  };
+  if (!settings.exists || !settings.valid) return result;
+
+  const sessionStart = settings.data?.hooks?.SessionStart || [];
+  const found = findMemexHookEntry(settings.data);
+  result.installed = found.found;
+  result.command = found.command;
+  result.otherSessionStartHooks = found.found
+    ? sessionStart.length - 1
+    : sessionStart.length;
+  return result;
+}
+
+export { MEMEX_COMMAND_MARKER, SETTINGS_PATH };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memex-mvp",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Local-first MCP server for cross-agent AI memory. One SQLite + FTS5 corpus across Claude Code, Cowork, Cursor, Continue, Zed, Obsidian, and Telegram — passively captured, verbatim, searchable from any MCP-compatible client.",
   "type": "module",
   "main": "server.js",
@@ -26,7 +26,7 @@
     "sync": "node ingest.js",
     "ingest": "node ingest.js",
     "bot": "node bot/index.js",
-    "test": "node test/parser.test.js && node test/bot-inbox.test.js && node test/search-sort.test.js && node test/store-document.test.js && node test/cli.test.js",
+    "test": "node test/parser.test.js && node test/bot-inbox.test.js && node test/search-sort.test.js && node test/store-document.test.js && node test/cli.test.js && node test/hook.test.js",
     "prepublishOnly": "npm test"
   },
   "engines": {

package/skills/install-memex/SKILL.md

@@ -122,16 +122,35 @@ If the config file doesn't exist, create the parent directory and write a minima
 
 **Verify:** re-read the file after save; confirm `memex` entry is present and `command` is an absolute path.
 
-### 3. Turn on live auto-capture
+### 3. Turn on live auto-capture + auto-context (v0.8+)
 
 ```sh
 memex-sync install
+```
+
+During `memex-sync install`, you'll see a prompt:
+
+```
+Auto-context (Brian Chesky mode):
+  When you open Claude Code in a project, memex can inject 500-1500 tokens
+  of relevant context so Claude knows what you were doing — without you
+  having to ask. Adds a SessionStart hook to ~/.claude/settings.json.
+  Other hooks (e.g. gstack) are preserved.
+
+  Enable? [Y/n]
+```
+
+**Answer Y unless the user has stated privacy concerns** about Claude seeing context from their other AI conversations. Auto-context is the "10/10 magic moment" of memex — without it the install ships at base capability. Other hooks (gstack, custom) are preserved untouched.
+
+For non-interactive flows (CI / scripts): pass `--auto-context yes` or `--yes`.
+
+```sh
 memex-sync status
 ```
 
 `status` should print "daemon installed", "running (PID …)", "watching N sessions".
 
-**Verify:** status output shows a non-zero PID.
+**Verify:** status output shows a non-zero PID. Also run `memex hook status` — should show `INSTALLED` if auto-context was accepted.
 
 ### 4. Backfill existing history
 
@@ -161,6 +180,7 @@ After restart, suggest they try any of:
 - "what projects has memex captured" → triggers `memex_list_projects`
 - "search memex for [recent topic]" → triggers `memex_search`
 - "save https://en.wikipedia.org/wiki/As_We_May_Think to memex" → triggers `memex_store_document` and teaches the user that URL-saving exists (v0.6+)
+- **Open Claude Code in any project the user worked on recently** — the SessionStart auto-context (v0.8+) should kick in and Claude will mention prior work _before_ the user types anything. This is the "Brian Chesky moment" — the magical-first-impression of memex.
 
 These confirm everything works end-to-end.