@pcircle/memesh 4.5.0 → 4.6.0

package/scripts/hooks/_generated/core-paths.js

@@ -6,8 +6,10 @@
 // always-on capture path survives a missing or stale dist/ while staying
 // byte-locked to core — eliminating the hand-mirror drift behind the P0 FTS bug.
 // ============================================================================
+import fs from 'fs';
 import os from 'os';
 import path from 'path';
+import { createHash } from 'crypto';
 import { execFileSync } from 'child_process';
 export function homeDir() {
     const home = process.env.HOME;
@@ -49,7 +51,15 @@ function resolveProjectIdentity(cwd) {
     const root = tryGit(cwd, ['rev-parse', '--show-toplevel']);
     if (root)
         return path.basename(root);
-    return path.basename(cwd);
+    let real;
+    try {
+        real = fs.realpathSync.native(cwd);
+    }
+    catch {
+        real = path.resolve(cwd);
+    }
+    const suffix = createHash('sha256').update(real).digest('hex').slice(0, 8);
+    return `${path.basename(real)}-${suffix}`;
 }
 function tryGit(cwd, args) {
     try {
@@ -75,3 +85,59 @@ export function slugFromRemoteUrl(url) {
 export function _clearProjectNameCache() {
     projectNameCache.clear();
 }
+export const SECRET_PATTERN_SOURCES = [
+    '-----BEGIN[A-Z ]*PRIVATE KEY-----[\\s\\S]*?-----END[A-Z ]*PRIVATE KEY-----',
+    '-----BEGIN[A-Z ]*PRIVATE KEY-----[\\s\\S]*?(?=\\n[ \\t]*\\n|$)',
+    '(?:postgres|postgresql|mysql|mariadb|mongodb(?:\\+srv)?|redis|rediss|amqp|amqps)://[^\\s:@/]+:[^\\s:@/]+@',
+    'eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}',
+    'SG\\.[A-Za-z0-9_-]{16,}\\.[A-Za-z0-9_-]{16,}',
+    '[srp]k_(?:live|test)_[A-Za-z0-9]{16,}',
+    'npm_[A-Za-z0-9]{36}',
+    'sk-ant-[A-Za-z0-9_-]{16,}',
+    'sk-[A-Za-z0-9_-]{16,}',
+    'sk_[A-Za-z0-9]{16,}',
+    'ghp_[A-Za-z0-9]{30,}',
+    'gho_[A-Za-z0-9]{30,}',
+    'gh[sur]_[A-Za-z0-9]{30,}',
+    'github_pat_[A-Za-z0-9_]{20,}',
+    'A(?:KIA|SIA)[A-Z0-9]{16}',
+    'AIza[A-Za-z0-9_-]{30,}',
+    'xox[baprs]-[A-Za-z0-9-]{10,}',
+    'Bearer(?:\\s|\\\\[nrt])+[A-Za-z0-9_.\\-]{16,}',
+];
+export function redactSecrets(input) {
+    let out = input;
+    for (const s of SECRET_PATTERN_SOURCES)
+        out = out.replace(new RegExp(s, 'gi'), '***REDACTED***');
+    return out;
+}
+export function redactUserPaths(text) {
+    const home = homeDir();
+    const roots = new Set();
+    const add = (root) => {
+        if (!root || !path.isAbsolute(root))
+            return;
+        roots.add(root);
+        try {
+            roots.add(fs.realpathSync(root));
+        }
+        catch { }
+    };
+    add(home);
+    const isInside = (child) => {
+        const rel = path.relative(home, child);
+        return rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+    };
+    for (const dir of [memeshDir(), path.dirname(getDbPath())]) {
+        if (dir && !isInside(dir))
+            add(dir);
+    }
+    const flags = process.platform === 'linux' ? 'g' : 'gi';
+    let out = text;
+    for (const root of [...roots].sort((a, b) => b.length - a.length)) {
+        const escaped = root.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const body = escaped.replace(/\\\\|\//g, '[\\\\/]{1,2}');
+        out = out.replace(new RegExp(`(?<![\\w~](?:[\\\\/]{1,2})?)${body}(?=[\\\\/]|$)`, flags), '~');
+    }
+    return out;
+}

package/scripts/hooks/_generated/fts-index.js

@@ -62,9 +62,12 @@ const LONE_UNSPACED_CHAR = new RegExp(`[${UNSPACED_SCRIPT_CLASS}]`, 'u');
 export function isLoneUnspacedChar(term) {
     return [...term].length === 1 && LONE_UNSPACED_CHAR.test(term);
 }
-export function removeFromFts(db, entityId, name, prevObsText) {
+function foldTitleIntoObservations(title, observationsText) {
+    return title ? `${title} ${observationsText}` : observationsText;
+}
+export function removeFromFts(db, entityId, name, prevObsText, prevTitle) {
     try {
-        db.prepare("INSERT INTO entities_fts (entities_fts, rowid, name, observations) VALUES('delete', ?, ?, ?)").run(entityId, toIndexForm(name), toIndexForm(prevObsText));
+        db.prepare("INSERT INTO entities_fts (entities_fts, rowid, name, observations) VALUES('delete', ?, ?, ?)").run(entityId, toIndexForm(name), toIndexForm(foldTitleIntoObservations(prevTitle, prevObsText)));
     }
     catch (err) {
         if (isBenignFtsDeleteError(err))
@@ -76,6 +79,15 @@ function isBenignFtsDeleteError(err) {
     const msg = err?.message ?? '';
     return /no such rowid|values do not match|no such row\b/i.test(msg);
 }
-export function insertFtsRow(db, entityId, name, observationsText) {
-    db.prepare('INSERT INTO entities_fts (rowid, name, observations) VALUES (?, ?, ?)').run(entityId, toIndexForm(name), toIndexForm(observationsText));
+export function joinIndexedObservations(contents) {
+    return contents.join(' ');
+}
+export function indexedObservationText(db, entityId) {
+    const rows = db
+        .prepare('SELECT content FROM observations WHERE entity_id = ? ORDER BY id')
+        .all(entityId);
+    return joinIndexedObservations(rows.map((o) => o.content));
+}
+export function insertFtsRow(db, entityId, name, observationsText, title) {
+    db.prepare('INSERT INTO entities_fts (rowid, name, observations) VALUES (?, ?, ?)').run(entityId, toIndexForm(name), toIndexForm(foldTitleIntoObservations(title, observationsText)));
 }

package/scripts/hooks/_generated/schema.js

@@ -0,0 +1,281 @@
+// ============================================================================
+// AUTO-GENERATED from src/storage/schema.ts — DO NOT EDIT BY HAND.
+// Regenerate with: npm run build  (scripts/generate-hook-core.mjs)
+//
+// Claude Code hooks import this committed copy instead of dist/, so the
+// always-on capture path survives a missing or stale dist/ while staying
+// byte-locked to core — eliminating the hand-mirror drift behind the P0 FTS bug.
+// ============================================================================
+import { insertFtsRow } from './fts-index.js';
+import { parseSqliteUtcMs } from './time-utils.js';
+export const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS entities (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  type TEXT NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  metadata JSON
+);
+
+CREATE TABLE IF NOT EXISTS observations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id INTEGER NOT NULL,
+  content TEXT NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE
+);
+
+CREATE TABLE IF NOT EXISTS relations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  from_entity_id INTEGER NOT NULL,
+  to_entity_id INTEGER NOT NULL,
+  relation_type TEXT NOT NULL,
+  metadata JSON,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (from_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+  FOREIGN KEY (to_entity_id) REFERENCES entities(id) ON DELETE CASCADE,
+  UNIQUE(from_entity_id, to_entity_id, relation_type)
+);
+
+CREATE TABLE IF NOT EXISTS tags (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id INTEGER NOT NULL,
+  tag TEXT NOT NULL,
+  FOREIGN KEY (entity_id) REFERENCES entities(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_tags_entity ON tags(entity_id);
+CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag);
+-- The tags dedup DELETE + idx_tags_entity_tag_unique creation live in
+-- ensureTagsUniqueIndex(), AFTER this exec — the DELETE is a one-time
+-- migration, and a DML statement in this string made every open start a
+-- write transaction even when it deleted nothing (same reader-breaking
+-- pattern as the hook_runs_since note below).
+CREATE INDEX IF NOT EXISTS idx_observations_entity ON observations(entity_id);
+CREATE INDEX IF NOT EXISTS idx_relations_from ON relations(from_entity_id);
+CREATE INDEX IF NOT EXISTS idx_relations_to ON relations(to_entity_id);
+CREATE INDEX IF NOT EXISTS idx_entities_type_created ON entities(type, created_at);
+
+-- Migration markers and small bits of persistent state (index segmentation
+-- version, embedding dimension, pending-reindex flags, backfill markers).
+--
+-- This used to be created ad hoc by each helper that needed it — four inline
+-- CREATE TABLE IF NOT EXISTS copies in src/db.ts, none of them visible to
+-- schema checks. A column added to one copy would not have been caught. It
+-- also meant the hook-side schema had no metadata table at all, so hooks
+-- could not participate in migrations even in principle.
+CREATE TABLE IF NOT EXISTS memesh_metadata (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+-- Proof that a capture hook actually RAN. Nothing else in this schema can
+-- give it: every other signal is "a row was written", and "the hook ran and
+-- found nothing worth saving" is the healthy case that produces no row at
+-- all. So a quiet day and a dead capture loop were byte-identical in the
+-- database, and the one doctor message that had to cover both cried wolf on
+-- the first and stayed silent on the second.
+--
+-- Written by the three hooks that hold a read-write handle (Stop, PreCompact,
+-- PostToolUse), each calling recordHookRun() at its own SUCCESSFUL exit —
+-- after capture, not at open. Stamping at open certified the wrong thing: a
+-- hook that opened the database and then died mid-capture looked alive for a
+-- day. "Successful" is precise: a completed capture, or a well-formed
+-- payload the hook correctly decided not to capture (dedup, low-signal
+-- session). A malformed payload (schema-flip shapes) and a write that did
+-- not land both leave no stamp — either would make the heartbeat mask the
+-- exact dropout it exists to expose. The recall-side hooks open read-only
+-- and deliberately do not appear here: their liveness answers a different
+-- question, and giving them a write handle would put a lock acquisition on
+-- the SessionStart hot path.
+--
+-- One row per hook, upserted. It does not grow.
+CREATE TABLE IF NOT EXISTS hook_runs (
+  hook        TEXT PRIMARY KEY,
+  last_run_at TIMESTAMP NOT NULL,
+  run_count   INTEGER NOT NULL DEFAULT 0
+);
+
+-- The 'hook_runs_since' metadata key (when this database first became able
+-- to record hook runs) is stamped by ensureHookRunsSince() AFTER this exec,
+-- NOT here. It used to be an INSERT OR IGNORE in this string, and that made
+-- every open — including opens that only ever read — start a write
+-- transaction: an INSERT statement takes the WAL writer lock even when
+-- OR IGNORE ends up changing nothing. Two states regressed from "reads work"
+-- to "open throws": a peer holding the writer lock past busy_timeout, and a
+-- read-only database FILE (measured: "attempt to write a readonly database"
+-- killed recall along with capture). The helper SELECTs first and writes
+-- only when the key is genuinely absent — once per database lifetime.
+`;
+export const FTS_SQL = `
+CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+  name, observations, content='',
+  tokenize='unicode61 remove_diacritics 1'
+);
+
+-- Term -> document-count view over the index above. Stores nothing of its own;
+-- it exists so search() can drop query terms that appear in most of the corpus,
+-- which are the ones BM25 already scores near zero. See dropUbiquitousTerms().
+CREATE VIRTUAL TABLE IF NOT EXISTS fts_vocab USING fts5vocab(entities_fts, 'row');
+`;
+export function safeAlter(db, sql) {
+    try {
+        db.exec(sql);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        if (!/duplicate column name/i.test(msg))
+            throw e;
+    }
+}
+export function migrateEntitiesSchema(db) {
+    const entityColumns = new Set(db.prepare("PRAGMA table_info(entities)").all().map((c) => c.name));
+    if (!entityColumns.has('status')) {
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN status TEXT NOT NULL DEFAULT 'active'");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_entities_status ON entities(status)");
+    }
+    if (!entityColumns.has('access_count')) {
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN access_count INTEGER DEFAULT 0");
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN last_accessed_at TIMESTAMP");
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN confidence REAL DEFAULT 1.0");
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN valid_from TIMESTAMP");
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN valid_until TIMESTAMP");
+    }
+    if (!entityColumns.has('namespace')) {
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN namespace TEXT DEFAULT 'personal'");
+        db.exec("CREATE INDEX IF NOT EXISTS idx_entities_namespace ON entities(namespace)");
+    }
+    if (!entityColumns.has('recall_hits')) {
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN recall_hits INTEGER DEFAULT 0");
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN recall_misses INTEGER DEFAULT 0");
+    }
+    if (!entityColumns.has('title')) {
+        safeAlter(db, "ALTER TABLE entities ADD COLUMN title TEXT");
+    }
+}
+export function ensureTagsUniqueIndex(db) {
+    try {
+        const present = db
+            .prepare("SELECT 1 FROM sqlite_master WHERE type = 'index' AND name = 'idx_tags_entity_tag_unique'")
+            .get();
+        if (present)
+            return;
+        db.exec('BEGIN IMMEDIATE; ' +
+            'DELETE FROM tags WHERE id NOT IN (SELECT MIN(id) FROM tags GROUP BY entity_id, tag); ' +
+            'CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_entity_tag_unique ON tags(entity_id, tag); ' +
+            'COMMIT;');
+    }
+    catch (err) {
+        try {
+            db.exec('ROLLBACK');
+        }
+        catch { }
+        try {
+            process.stderr.write(`MeMesh: could not create the tags unique index (${err instanceof Error ? err.message : String(err)}). ` +
+                `Reads are unaffected; the next open retries the dedup and index together.\n`);
+        }
+        catch { }
+    }
+}
+export function ensureHookRunsSince(db) {
+    try {
+        const row = db
+            .prepare("SELECT value FROM memesh_metadata WHERE key = 'hook_runs_since'")
+            .get();
+        if (row) {
+            const then = parseSqliteUtcMs(row.value ?? '');
+            if (then !== null && then <= Date.now() + 5 * 60 * 1000)
+                return;
+            db
+                .prepare("UPDATE memesh_metadata SET value = datetime('now') WHERE key = 'hook_runs_since'")
+                .run();
+            return;
+        }
+        db
+            .prepare("INSERT OR IGNORE INTO memesh_metadata (key, value) VALUES ('hook_runs_since', datetime('now'))")
+            .run();
+    }
+    catch (err) {
+        try {
+            process.stderr.write(`MeMesh: could not stamp hook_runs_since (${err instanceof Error ? err.message : String(err)}). ` +
+                `Reads are unaffected; doctor's hook-activity tracking starts once the database is writable.\n`);
+        }
+        catch { }
+    }
+}
+export function isTransientDbError(err) {
+    const code = err?.code ?? '';
+    const msg = err?.message ?? '';
+    return (/SQLITE_BUSY|SQLITE_LOCKED|SQLITE_PROTOCOL/.test(code) ||
+        /database is locked|database table is locked|locking protocol/i.test(msg));
+}
+export const MIGRATION_RETRY_BACKOFF_MS = 24 * 60 * 60 * 1000;
+export function runOnceMigration(db, opts) {
+    const { key, version, describe, migrate } = opts;
+    const attemptKey = `${key}_last_attempt`;
+    const readMarker = (k) => db.prepare('SELECT value FROM memesh_metadata WHERE key = ?').get(k)?.value;
+    const stored = readMarker(key);
+    if (stored && parseInt(stored, 10) >= version)
+        return false;
+    const lastAttempt = readMarker(attemptKey);
+    if (lastAttempt && Date.now() - parseInt(lastAttempt, 10) < MIGRATION_RETRY_BACKOFF_MS) {
+        return false;
+    }
+    try {
+        db.transaction(() => {
+            const current = readMarker(key);
+            if (current && parseInt(current, 10) >= version)
+                return;
+            migrate(db, current ? parseInt(current, 10) : 0);
+            db.prepare('INSERT OR REPLACE INTO memesh_metadata (key, value) VALUES (?, ?)').run(key, String(version));
+            db.prepare('DELETE FROM memesh_metadata WHERE key = ?').run(attemptKey);
+        }).immediate();
+        return true;
+    }
+    catch (err) {
+        if (isTransientDbError(err)) {
+            process.stderr.write(`MeMesh: ${describe} deferred (${err instanceof Error ? err.message : String(err)}). ` +
+                `Another process holds the database; it will run on the next start.\n`);
+            return false;
+        }
+        try {
+            db.prepare('INSERT OR REPLACE INTO memesh_metadata (key, value) VALUES (?, ?)').run(attemptKey, String(Date.now()));
+        }
+        catch { }
+        process.stderr.write(`MeMesh: ${describe} failed (${err instanceof Error ? err.message : String(err)}). ` +
+            `Your memories are unaffected — this rebuilds a derived index. ` +
+            `It will retry in 24h, or run 'memesh reindex --fts' to retry now.\n`);
+        return false;
+    }
+}
+export const FTS_SEGMENTATION_VERSION = 3;
+export const FTS_REBUILD_PAGE_SIZE = 500;
+export function rebuildFtsIndex(db) {
+    db.exec("INSERT INTO entities_fts (entities_fts) VALUES('delete-all')");
+    const page = db.prepare(`SELECT e.id, e.name, e.title, COALESCE(group_concat(o.content, ' ' ORDER BY o.id), '') AS obs
+       FROM entities e
+       LEFT JOIN observations o ON o.entity_id = e.id
+      WHERE e.status = 'active' AND e.id > ?
+      GROUP BY e.id
+      ORDER BY e.id
+      LIMIT ?`);
+    let afterId = 0;
+    for (;;) {
+        const rows = page.all(afterId, FTS_REBUILD_PAGE_SIZE);
+        if (rows.length === 0)
+            break;
+        for (const row of rows)
+            insertFtsRow(db, row.id, row.name, row.obs, row.title);
+        afterId = rows[rows.length - 1].id;
+        if (rows.length < FTS_REBUILD_PAGE_SIZE)
+            break;
+    }
+}
+export function ensureFtsSegmentation(db) {
+    runOnceMigration(db, {
+        key: 'fts_segmentation_version',
+        version: FTS_SEGMENTATION_VERSION,
+        describe: 'search index rebuild',
+        migrate: rebuildFtsIndex,
+    });
+}

package/scripts/hooks/_generated/sqlite.js

@@ -0,0 +1,71 @@
+// ============================================================================
+// AUTO-GENERATED from src/storage/sqlite.ts — DO NOT EDIT BY HAND.
+// Regenerate with: npm run build  (scripts/generate-hook-core.mjs)
+//
+// Claude Code hooks import this committed copy instead of dist/, so the
+// always-on capture path survives a missing or stale dist/ while staying
+// byte-locked to core — eliminating the hand-mirror drift behind the P0 FTS bug.
+// ============================================================================
+import { createRequire } from 'node:module';
+function loadNodeSqlite() {
+    const require = createRequire(import.meta.url);
+    const original = process.emitWarning;
+    process.emitWarning = function (warning, ...rest) {
+        const text = typeof warning === 'string' ? warning : String(warning?.message ?? warning);
+        if (text.includes('SQLite is an experimental feature'))
+            return;
+        return original.call(process, warning, ...rest);
+    };
+    try {
+        return require('node:sqlite');
+    }
+    catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        throw new Error(`memesh needs Node's built-in SQLite, which this runtime (${process.version}) does not provide. ` +
+            'It became usable without a flag in Node 22.13.0 — upgrade Node to 22.13 or newer and run memesh again. ' +
+            `(${detail})`, { cause: err });
+    }
+    finally {
+        process.emitWarning = original;
+    }
+}
+const { DatabaseSync } = loadNodeSqlite();
+const BUSY_TIMEOUT_MS = 5000;
+export class MemeshDatabase extends DatabaseSync {
+    #depth = 0;
+    constructor(path, options = {}) {
+        super(path, options);
+        this.pragma(`busy_timeout = ${BUSY_TIMEOUT_MS}`);
+    }
+    pragma(statement) {
+        this.exec(`PRAGMA ${statement}`);
+    }
+    transaction(fn) {
+        const run = (mode, ...args) => {
+            const nested = this.#depth > 0;
+            const savepoint = `memesh_sp_${this.#depth}`;
+            this.exec(nested ? `SAVEPOINT ${savepoint}` : `BEGIN${mode}`);
+            this.#depth++;
+            try {
+                const result = fn(...args);
+                this.exec(nested ? `RELEASE ${savepoint}` : 'COMMIT');
+                return result;
+            }
+            catch (err) {
+                try {
+                    this.exec(nested ? `ROLLBACK TO ${savepoint}` : 'ROLLBACK');
+                    if (nested)
+                        this.exec(`RELEASE ${savepoint}`);
+                }
+                catch { }
+                throw err;
+            }
+            finally {
+                this.#depth--;
+            }
+        };
+        const callable = ((...args) => run('', ...args));
+        callable.immediate = (...args) => run(' IMMEDIATE', ...args);
+        return callable;
+    }
+}

package/scripts/hooks/_generated/task-state.js

@@ -0,0 +1,98 @@
+// ============================================================================
+// AUTO-GENERATED from src/core/task-state.ts — DO NOT EDIT BY HAND.
+// Regenerate with: npm run build  (scripts/generate-hook-core.mjs)
+//
+// Claude Code hooks import this committed copy instead of dist/, so the
+// always-on capture path survives a missing or stale dist/ while staying
+// byte-locked to core — eliminating the hand-mirror drift behind the P0 FTS bug.
+// ============================================================================
+export const TASK_STATE_TYPE = 'task-state';
+export const TASK_STATE_FIELDS = ['goal', 'next', 'blocked', 'done'];
+export const MAX_FIELD_CHARS = 300;
+export function taskStateName(project) {
+    return `${TASK_STATE_TYPE}:${project}`;
+}
+export function parseTaskState(metadata) {
+    const state = {};
+    if (!metadata || typeof metadata !== 'object')
+        return state;
+    const raw = metadata.task_state;
+    if (!raw || typeof raw !== 'object')
+        return state;
+    const bag = raw;
+    for (const field of TASK_STATE_FIELDS) {
+        const value = bag[field];
+        if (typeof value !== 'string')
+            continue;
+        const trimmed = value.trim();
+        if (trimmed)
+            state[field] = trimmed;
+    }
+    const updated = bag.updated_at;
+    if (typeof updated === 'string' && updated.trim())
+        state.updated_at = updated.trim();
+    return state;
+}
+export function normalizeFieldValue(value) {
+    const flat = value.replace(/\s+/g, ' ').trim();
+    if (!flat)
+        return null;
+    return flat.length > MAX_FIELD_CHARS ? `${flat.slice(0, MAX_FIELD_CHARS - 1).trimEnd()}…` : flat;
+}
+export function mergeTaskState(previous, patch, now) {
+    const state = { ...previous };
+    const changed = [];
+    const observations = [];
+    for (const field of TASK_STATE_FIELDS) {
+        const incoming = patch[field];
+        if (incoming === undefined)
+            continue;
+        const normalized = normalizeFieldValue(incoming);
+        const current = state[field];
+        if (normalized === (current ?? null))
+            continue;
+        changed.push(field);
+        if (normalized === null) {
+            delete state[field];
+            observations.push(`${field} cleared`);
+        }
+        else {
+            state[field] = normalized;
+            observations.push(`${field}: ${normalized}`);
+        }
+    }
+    if (changed.length > 0)
+        state.updated_at = now;
+    return { state, changed, observations };
+}
+export function isEmptyTaskState(state) {
+    return TASK_STATE_FIELDS.every((field) => !state[field]);
+}
+const FIELD_LABELS = {
+    goal: 'Goal',
+    next: 'Next',
+    blocked: 'Blocked',
+    done: 'Just finished',
+};
+function ageInDays(updatedAt, now) {
+    if (!updatedAt)
+        return null;
+    const then = Date.parse(updatedAt);
+    if (Number.isNaN(then))
+        return null;
+    const days = Math.floor((now.getTime() - then) / 86_400_000);
+    return days >= 0 ? days : null;
+}
+export function taskStateLines(state, project, now = new Date()) {
+    if (isEmptyTaskState(state))
+        return [];
+    const days = ageInDays(state.updated_at, now);
+    const age = days === null ? '' : days === 0 ? ' (today)' : days === 1 ? ' (yesterday)' : ` (${days} days ago)`;
+    const lines = [`Where "${project}" was left off${age}:`];
+    for (const field of TASK_STATE_FIELDS) {
+        const value = state[field];
+        if (value)
+            lines.push(`- ${FIELD_LABELS[field]}: ${value}`);
+    }
+    return lines;
+}

package/scripts/hooks/_generated/time-utils.js

@@ -0,0 +1,21 @@
+// ============================================================================
+// AUTO-GENERATED from src/core/time-utils.ts — DO NOT EDIT BY HAND.
+// Regenerate with: npm run build  (scripts/generate-hook-core.mjs)
+//
+// Claude Code hooks import this committed copy instead of dist/, so the
+// always-on capture path survives a missing or stale dist/ while staying
+// byte-locked to core — eliminating the hand-mirror drift behind the P0 FTS bug.
+// ============================================================================
+export function parseSqliteUtcMs(sqliteTimestamp) {
+    const m = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})$/.exec(sqliteTimestamp ?? '');
+    if (!m)
+        return null;
+    const then = Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]);
+    if (!Number.isFinite(then))
+        return null;
+    const d = new Date(then);
+    if (d.getUTCFullYear() !== +m[1] || d.getUTCMonth() !== +m[2] - 1 || d.getUTCDate() !== +m[3]
+        || d.getUTCHours() !== +m[4] || d.getUTCMinutes() !== +m[5] || d.getUTCSeconds() !== +m[6])
+        return null;
+    return then;
+}

package/scripts/hooks/_generated/title.js

@@ -0,0 +1,21 @@
+// ============================================================================
+// AUTO-GENERATED from src/core/title.ts — DO NOT EDIT BY HAND.
+// Regenerate with: npm run build  (scripts/generate-hook-core.mjs)
+//
+// Claude Code hooks import this committed copy instead of dist/, so the
+// always-on capture path survives a missing or stale dist/ while staying
+// byte-locked to core — eliminating the hand-mirror drift behind the P0 FTS bug.
+// ============================================================================
+export const TITLE_MAX_LENGTH = 200;
+export function truncateTitle(text) {
+    if (!text)
+        return text;
+    const trimmed = text.trim();
+    return trimmed.length > TITLE_MAX_LENGTH
+        ? trimmed.slice(0, TITLE_MAX_LENGTH - 1).trimEnd() + '…'
+        : trimmed;
+}
+export const BOILERPLATE_OBSERVATION_PATTERN = /^(Steps|Commits|Branch|Diff stats|Compaction reason|Tool calls|Plan ".+" completed)[:\s]/;
+export function isBoilerplateObservation(text) {
+    return BOILERPLATE_OBSERVATION_PATTERN.test(text.trim());
+}