hafez 1.4.0 → 2.0.0

package/dist/harness.js

@@ -0,0 +1,50 @@
+// src/harness.ts
+// Which Harness is running this command, read from the environment. The one
+// helper the Apply update arm, the CLI's --log and `digest` call to name the
+// agent in a session log, and `onboard` calls to pick the Harness it sets up.
+// Also where each Harness keeps its instructions file.
+/** Recorded when no Harness is detectable. */
+export const NEUTRAL_AGENT = 'agent';
+/** Variables Codex sets on the commands it runs. CODEX_HOME and the Claude
+ * Code plugin's CODEX_COMPANION_* are deliberately absent: both can be set in
+ * a shell Codex is not running. */
+const CODEX_VARS = ['CODEX_THREAD_ID', 'CODEX_SANDBOX', 'CODEX_SANDBOX_NETWORK_DISABLED'];
+export function detectAgent(env = process.env) {
+    const set = (key) => Boolean(env[key]);
+    // Codex first: Codex started from inside Claude Code inherits CLAUDECODE,
+    // and the innermost Harness is the one running the command.
+    if (CODEX_VARS.some(set))
+        return 'codex';
+    if (set('CLAUDECODE'))
+        return 'claude-code';
+    return NEUTRAL_AGENT;
+}
+/** Every Harness `onboard` can configure, and where its always-loaded
+ * user-level instructions file lives, relative to the home directory (harness
+ * research, docs/research/2026-09-29-harness-instruction-surfaces.md): the
+ * first candidate that exists, else the last. Cursor keeps its User Rules in a
+ * Settings UI, not a file: `null`, and the Block is printed for manual paste.
+ * `dir` is the config directory whose presence says the Harness is installed. */
+export const HARNESSES = {
+    'claude-code': { label: 'Claude Code', dir: '.claude', instructions: ['.claude/CLAUDE.md'] },
+    codex: { label: 'Codex', dir: '.codex', instructions: ['.codex/AGENTS.override.md', '.codex/AGENTS.md'] },
+    cursor: { label: 'Cursor', dir: '.cursor', instructions: null },
+    gemini: { label: 'Gemini CLI', dir: '.gemini', instructions: ['.gemini/GEMINI.md'] },
+    copilot: { label: 'Copilot CLI', dir: '.copilot', instructions: ['.copilot/copilot-instructions.md'] },
+};
+/** The Harnesses bare `onboard` sets up from inside — the ones detected from
+ * the environment — and, relative to the home directory, where each keeps
+ * what the agent applies: the SessionStart hook and the permission entries.
+ * `keystroke` invokes the `hafez-save` skill there. */
+export const ONBOARD_HARNESSES = {
+    'claude-code': { keystroke: '/hafez-save', hooks: '.claude/settings.json', allowEntry: 'Bash(hafez:*)' },
+    codex: {
+        keystroke: '$hafez-save',
+        hooks: '.codex/hooks.json',
+        rules: '.codex/rules/default.rules',
+        rule: 'prefix_rule(pattern = ["hafez"], decision = "allow")',
+        config: '.codex/config.toml',
+    },
+};
+export const isOnboardHarness = (value) => Object.hasOwn(ONBOARD_HARNESSES, value);
+export const isHarness = (value) => Object.hasOwn(HARNESSES, value);

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import type { Hafez, HafezConfig } from './types.js';
 export declare function createHafez(config: HafezConfig): Hafez;
 export { HafezError } from './types.js';
-export type { Hafez, HafezConfig, HafezErrorCode, EntityType, EntityStatus, EntityQueryOpts, KnowledgeQueryOpts, UnifiedQueryOpts, EntityFrontmatter, KnowledgeFrontmatter, ParsedFile, SessionLogEntry, UpdateFields, UpdateResult, CreateEntityFields, CreateKnowledgeFields, QueryFilter, QueryResult, KnowledgeQueryResult, UnifiedResult, ValidationReport, BatchOperation, BatchResult, ReadDepth, ConfidenceLevel, LinkRelation, GitConfig, Journal, SearchResult, VaultStats, ChangelogEntry, KnowledgeSubtype } from './types.js';
+export type { Hafez, HafezConfig, HafezErrorCode, EntityType, EntityStatus, EntityQueryOpts, KnowledgeQueryOpts, UnifiedQueryOpts, AllQueryOpts, SortField, EntitySortField, EntityFrontmatter, KnowledgeFrontmatter, ParsedFile, SessionLogEntry, UpdateFields, UpdateResult, CreateEntityFields, CreateKnowledgeFields, QueryFilter, QueryResult, KnowledgeQueryResult, UnifiedResult, ValidationReport, BatchOperation, BatchResult, ReadDepth, ConfidenceLevel, LinkRelation, GitConfig, Journal, SearchResult, VaultStats, ChangelogEntry, KnowledgeSubtype } from './types.js';
 export { getBrief, getNextActions } from './document.js';
 export { parseSessionLogHeading, parseSessionLog } from './document.js';

package/dist/index.js

@@ -1,12 +1,14 @@
 // src/index.ts
-import { parseFilePath, slugify, kindFromPath, kindDir, scanVaultDir, isIndexedRelPath, findVaultFile, vaultFileExists } from './vault.js';
+import { parseFilePath, slugify, kindFromPath, kindDir, isIndexedRelPath, findVaultFile, vaultFileExists, resolveFilePath, scanVaultDir, INDEXED_KINDS } from './vault.js';
 import { createGitJournal } from './git.js';
-import { validateEntityFrontmatter, validateKnowledgeFrontmatter, validateSessionLogEntry } from './schema.js';
+import { validateSessionLogEntry } from './schema.js';
+import { validateVault } from './validate.js';
 import { documentForFile } from './document.js';
 import { createIndex } from './db.js';
+import { closestSlugs } from './closest.js';
 import { generateVaultIndex } from './knowledge-index.js';
 import { HafezError } from './types.js';
-import { BatchOperationSchema, specFor, slugBearingOpNames, notFoundError, normalizeOperations, opErrorLine, batchInvalidHeader } from './batch-ops.js';
+import { BatchOperationSchema, specFor, slugBearingOpNames, sessionAddressingOpNames, notFoundError, normalizeOperations, opErrorLine, batchInvalidHeader } from './batch-ops.js';
 import { applyOperation, buildEntityFrontmatter, buildKnowledgeFrontmatter, validateKindFields } from './apply.js';
 import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
 import { join, basename } from 'path';
@@ -91,19 +93,22 @@ export function createHafez(config) {
     }
     async function read(slug, depth = 'summary') {
         const filePath = findFile(slug);
-        if (!filePath)
-            throw new HafezError('NOT_FOUND', `Entity or knowledge '${slug}' not found`);
+        if (!filePath) {
+            // A miss carries the closest slugs as its details: the recovery the
+            // `read` miss output renders (#91).
+            const closest = withIndex(idx => { idx.syncIfStale(); return closestSlugs(slug, idx.indexEntries()); }, []);
+            throw new HafezError('NOT_FOUND', `Entity or knowledge '${slug}' not found`, closest);
+        }
         const parsed = parseFilePath(filePath);
         // findFile only resolves the indexed kinds, so the session arm is unreachable
-        const kind = parsed.kind === 'session' ? 'knowledge' : parsed.kind;
-        const frontmatter = parsed.frontmatter;
-        const body = parsed.body;
+        if (parsed.kind === 'session')
+            throw new HafezError('NOT_FOUND', `Entity or knowledge '${slug}' not found`);
         if (depth === 'frontmatter')
-            return { kind, frontmatter, body: '' };
+            return { ...parsed, body: '' };
         if (depth === 'summary') {
-            return { kind, frontmatter, body: documentForFile(parsed).bodyBeforeSessionLog(body) };
+            return { ...parsed, body: documentForFile(parsed).bodyBeforeSessionLog(parsed.body) };
         }
-        return { kind, frontmatter, body };
+        return parsed;
     }
     function rollbackFiles(originals) {
         for (const [path, content] of originals) {
@@ -259,7 +264,7 @@ export function createHafez(config) {
     }
     async function update(slug, fields) {
         const { applied } = await runMutations([{ op: 'update', slug, fields }], { action: 'update' });
-        return { matched_action: applied[0].matchedAction };
+        return applied[0].updateResult ?? {};
     }
     async function link(slug, target, relation) {
         await runMutations([{ op: 'link', slug, target, relation }], { action: 'link' });
@@ -267,6 +272,10 @@ export function createHafez(config) {
     async function unlink(slug, target, relation) {
         await runMutations([{ op: 'unlink', slug, target, relation }], { action: 'unlink' });
     }
+    async function del(slug) {
+        const { applied } = await runMutations([{ op: 'delete', slug }], { action: 'delete' });
+        return applied[0].deletedKind;
+    }
     // "Recent" with day-granularity dates: primary sort is the frontmatter day,
     // ties break on git commit time (the real recency signal), then name for
     // files with no commit history yet. Without this the top-5 lists leak
@@ -303,10 +312,36 @@ export function createHafez(config) {
         // slug → what it would be after earlier ops in this batch
         const simulated = new Map();
         const simulatedSessions = new Set();
-        const existsAnywhere = (slug) => simulated.has(slug) || exists(slug);
+        // Deletes earlier in the batch: the slug is absent to every later op, so
+        // delete-then-create of one slug is a rewrite, not a collision.
+        const deleted = new Set();
+        const deletedSessions = new Set();
+        // slug → its parent/related after the earlier ops; files absent here
+        // carry what is on disk.
+        const simulatedLinks = new Map();
+        const existsAnywhere = (slug) => !deleted.has(slug) && (simulated.has(slug) || exists(slug));
+        const linksOf = (slug) => {
+            const sim = simulatedLinks.get(slug);
+            if (sim)
+                return sim;
+            const fp = findFile(slug);
+            if (!fp)
+                return {};
+            try {
+                const pf = parseFilePath(fp);
+                if (pf.kind === 'entity')
+                    return { parent: pf.frontmatter.parent, related: pf.frontmatter.related };
+                return { related: pf.frontmatter.related };
+            }
+            catch {
+                return {};
+            }
+        };
         // Vault context for the Op Spec table's semantic checks (src/batch-ops.ts).
         const ctx = {
             resolve: (slug) => {
+                if (deleted.has(slug))
+                    return null;
                 const sim = simulated.get(slug);
                 if (sim)
                     return sim;
@@ -335,9 +370,48 @@ export function createHafez(config) {
                 }
             },
             existsAnywhere,
-            sessionExists: (slug) => existsSync(join(vaultPath, kindDir('session'), `${slug}.md`)) || simulatedSessions.has(slug),
-            simulate: (slug, info) => { simulated.set(slug, info); },
-            simulateSession: (slug) => { simulatedSessions.add(slug); },
+            // resolveFilePath, not a bare join: delete acts on this answer, and a
+            // '../' slug must never reach a file outside sessions/.
+            sessionExists: (slug) => {
+                if (deletedSessions.has(slug))
+                    return false;
+                if (simulatedSessions.has(slug))
+                    return true;
+                try {
+                    return existsSync(resolveFilePath(vaultPath, slug, 'session'));
+                }
+                catch {
+                    return false;
+                }
+            },
+            simulate: (slug, info) => { deleted.delete(slug); simulated.set(slug, info); },
+            simulateSession: (slug) => { deletedSessions.delete(slug); simulatedSessions.add(slug); },
+            linksOf,
+            simulateLinks: (slug, links) => { simulatedLinks.set(slug, links); },
+            // Read from disk, not the index: the validate phase must see the vault
+            // as `validate` will, and a stale index row would let a linked note go.
+            referrers: (slug) => {
+                const candidates = new Set(simulated.keys());
+                for (const kind of INDEXED_KINDS) {
+                    for (const fp of scanVaultDir(join(vaultPath, kindDir(kind))))
+                        candidates.add(basename(fp, '.md'));
+                }
+                return [...candidates]
+                    .filter(from => from !== slug && !deleted.has(from))
+                    .filter(from => { const l = linksOf(from); return l.parent === slug || (l.related ?? []).includes(slug); })
+                    .sort();
+            },
+            simulateDelete: (slug, kind) => {
+                if (kind === 'session') {
+                    deletedSessions.add(slug);
+                    simulatedSessions.delete(slug);
+                    return;
+                }
+                deleted.add(slug);
+                simulated.delete(slug);
+                // A file created under this slug later in the batch starts unlinked.
+                simulatedLinks.set(slug, {});
+            },
             validateKindFields,
             validateSessionLogEntry: (entry) => validateSessionLogEntry(entry),
             buildEntityFrontmatter: (name, fields) => { buildEntityFrontmatter(name, fields, existsAnywhere); },
@@ -369,7 +443,8 @@ export function createHafez(config) {
                 // first (and scripts branch on its exit code) — keep that precedence.
                 if (raw && typeof raw.slug === 'string' && raw.slug &&
                     slugBearingOpNames().includes(entry.op) &&
-                    !existsAnywhere(raw.slug)) {
+                    !existsAnywhere(raw.slug) &&
+                    !(sessionAddressingOpNames().includes(entry.op) && ctx.sessionExists(raw.slug))) {
                     entry.errors.unshift(notFoundError(raw.slug));
                     entry.primaryCode = 'NOT_FOUND';
                 }
@@ -399,93 +474,7 @@ export function createHafez(config) {
         return results;
     }
     async function validate() {
-        const report = {
-            broken_slugs: [],
-            orphaned_knowledge: [],
-            oversized_related: [],
-            missing_fields: [],
-            total_entities: 0,
-            total_knowledge: 0,
-        };
-        const allSlugs = new Set();
-        const knowledgeSlugs = new Set();
-        const referencedKnowledge = new Set();
-        // Scan entities
-        const entDir = join(vaultPath, kindDir('entity'));
-        {
-            const files = scanVaultDir(entDir);
-            report.total_entities = files.length;
-            for (const filePath of files) {
-                const slug = basename(filePath, '.md');
-                allSlugs.add(slug);
-                let fm;
-                try {
-                    fm = parseFilePath(filePath).frontmatter;
-                }
-                catch {
-                    report.missing_fields.push({ slug, field: '', issue: 'failed to parse frontmatter' });
-                    continue;
-                }
-                const errors = validateEntityFrontmatter(fm);
-                for (const e of errors)
-                    report.missing_fields.push({ slug, field: '', issue: e });
-                if (fm.parent) {
-                    if (!exists(fm.parent))
-                        report.broken_slugs.push({ slug, field: 'parent', issue: `parent '${fm.parent}' does not exist` });
-                }
-                if (fm.related && Array.isArray(fm.related)) {
-                    for (const r of fm.related) {
-                        if (!exists(r))
-                            report.broken_slugs.push({ slug, field: 'related', issue: `related '${r}' does not exist` });
-                        // Track referenced knowledge
-                        referencedKnowledge.add(r);
-                    }
-                }
-            }
-        }
-        // Scan knowledge
-        const knDir = join(vaultPath, kindDir('knowledge'));
-        {
-            const files = scanVaultDir(knDir);
-            report.total_knowledge = files.length;
-            for (const filePath of files) {
-                const slug = basename(filePath, '.md');
-                allSlugs.add(slug);
-                knowledgeSlugs.add(slug);
-                let fm;
-                try {
-                    fm = parseFilePath(filePath).frontmatter;
-                }
-                catch {
-                    report.missing_fields.push({ slug, field: '', issue: 'failed to parse frontmatter' });
-                    continue;
-                }
-                const errors = validateKnowledgeFrontmatter(fm);
-                for (const e of errors)
-                    report.missing_fields.push({ slug, field: '', issue: e });
-                if (fm.related && Array.isArray(fm.related)) {
-                    for (const r of fm.related) {
-                        if (!exists(r))
-                            report.broken_slugs.push({ slug, field: 'related', issue: `related '${r}' does not exist` });
-                    }
-                }
-            }
-        }
-        // Find orphaned knowledge: no related, and not referenced by any entity
-        for (const slug of knowledgeSlugs) {
-            let fm;
-            try {
-                fm = parseFilePath(join(knDir, `${slug}.md`)).frontmatter;
-            }
-            catch {
-                continue; // already reported above
-            }
-            const hasRelated = fm.related && Array.isArray(fm.related) && fm.related.length > 0;
-            if (!hasRelated && !referencedKnowledge.has(slug)) {
-                report.orphaned_knowledge.push(slug);
-            }
-        }
-        return report;
+        return validateVault(vaultPath);
     }
     async function promote(slug, target) {
         // Rollback safety rides the Spine: applyOperation's promote arm captures
@@ -512,6 +501,7 @@ export function createHafez(config) {
         capture,
         link,
         unlink,
+        delete: del,
         batch,
         // Same normalization as the apply path — dry-run must judge the payload
         // apply would actually run.

package/dist/merge.js

@@ -1,6 +1,6 @@
 // src/merge.ts
 import { parseContent, serializeFile, ARRAY_FIELDS } from './vault.js';
-import { parseSessionLogHeading, splitLogEntries, documentFor } from './document.js';
+import { parseSessionLogHeading, splitLogEntries, documentFor, stripActionStamp } from './document.js';
 import { APPEND_ONLY_SECTIONS } from './contracts.js';
 // Fields that are ISO date strings — latest date wins
 const DATE_FIELDS = ['last-touched', 'last-reinforced', 'created'];
@@ -168,14 +168,16 @@ function parseLogEntries(content) {
 function mergeNextActions(remoteContent, localContent) {
     const remote = parseActionItems(remoteContent);
     const local = parseActionItems(localContent);
-    // Start with local items; index by action text for the remote pass
+    // Start with local items; index by action text for the remote pass. Identity
+    // is the unstamped text: one action stamped on two days is one action, and
+    // the local line (its stamp included) wins.
     const merged = local.items.map(i => ({ ...i, notes: [...i.notes] }));
-    const byText = new Map(merged.map(i => [i.text, i]));
+    const byText = new Map(merged.map(i => [stripActionStamp(i.text), i]));
     for (const item of remote.items) {
-        const existing = byText.get(item.text);
+        const existing = byText.get(stripActionStamp(item.text));
         if (!existing) {
             merged.push({ ...item, notes: [...item.notes] });
-            byText.set(item.text, merged[merged.length - 1]);
+            byText.set(stripActionStamp(item.text), merged[merged.length - 1]);
             continue;
         }
         // Checked on either side means done

package/dist/near-match.d.ts

@@ -0,0 +1,9 @@
+/** The notes whose names near-match `name` — all but one of the shorter
+ * name's tokens shared, at least three — and those that only resemble it (two
+ * shared or more). Up to three of each, most tokens shared first. */
+export declare function resemblances<T extends {
+    name: string;
+}>(name: string, notes: readonly T[]): {
+    near: T[];
+    weak: T[];
+};

package/dist/near-match.js

@@ -0,0 +1,34 @@
+// src/near-match.ts
+// The Near-match rule (decision #60): how closely a new knowledge note's name
+// resembles existing ones. Names only, never bodies, so the verdict is
+// deterministic and explainable. Tokens are the name's words, lowercased,
+// with the search stopwords dropped.
+import { tokenize } from './stopwords.js';
+/** A near-match shares at least this many tokens, whatever the name lengths. */
+const NEAR_MIN_SHARED = 3;
+/** A weaker resemblance shares at least this many. */
+const WEAK_MIN_SHARED = 2;
+/** Each list holds at most this many notes. */
+const MAX_LISTED = 3;
+function tokens(name) {
+    return new Set(tokenize(name));
+}
+/** The notes whose names near-match `name` — all but one of the shorter
+ * name's tokens shared, at least three — and those that only resemble it (two
+ * shared or more). Up to three of each, most tokens shared first. */
+export function resemblances(name, notes) {
+    const mine = tokens(name);
+    const near = [];
+    const weak = [];
+    for (const note of notes) {
+        const theirs = tokens(note.name);
+        const shared = [...mine].filter(t => theirs.has(t)).length;
+        const shorter = Math.min(mine.size, theirs.size);
+        if (shared >= Math.max(NEAR_MIN_SHARED, shorter - 1))
+            near.push({ note, shared });
+        else if (shared >= WEAK_MIN_SHARED)
+            weak.push({ note, shared });
+    }
+    const top = (xs) => xs.sort((a, b) => b.shared - a.shared).slice(0, MAX_LISTED).map(x => x.note);
+    return { near: top(near), weak: top(weak) };
+}

package/dist/stale.d.ts

@@ -0,0 +1,41 @@
+/** The threshold an entity without `staleness-days` gets. */
+export declare const DEFAULT_STALENESS_DAYS = 14;
+/** An open action's added day, its age in days, and whether it is stale;
+ * undated gives null for both. */
+export interface ActionAge {
+    added: string | null;
+    age_days: number | null;
+    stale: boolean;
+}
+/** The entity side of the rule, as SQL over an index row `i` with `@today`
+ * bound to localDay(): whole days from its last-touched day to today.
+ * julianday of two bare YYYY-MM-DD days differs by exactly `dayNumber`'s
+ * difference, so entities and their actions count the same days. */
+export declare const ENTITY_AGE_DAYS_SQL = "CAST(julianday(@today) - julianday(i.last_touched) AS INTEGER)";
+/** An entity row is stale when its age is past its threshold, not equal to
+ * it — `actionAge`'s rule. */
+export declare const ENTITY_STALE_SQL = "CAST(julianday(@today) - julianday(i.last_touched) AS INTEGER) > COALESCE(i.staleness_days, 14)";
+/** How old an action added on `added` is today, and whether that is past
+ * `stalenessDays`: older than the threshold, not equal to it. */
+export declare function actionAge(added: string | null, stalenessDays: number, today?: string): ActionAge;
+/** An entity's threshold: its `staleness-days`, else the default. */
+export declare function stalenessDaysOf(frontmatter: {
+    'staleness-days'?: number;
+}): number;
+/** One line of Next Actions as `read --json` gives it: an open line with its
+ * Handle and age, a ticked line as text alone. */
+export type AgedAction = ({
+    handle: string;
+    text: string;
+} & ActionAge) | {
+    text: string;
+};
+/** An entity body's Next Actions in file order, each open line aged against
+ * the entity's threshold. */
+export declare function agedActions(body: string, frontmatter: {
+    'staleness-days'?: number;
+}): AgedAction[];
+/** The Handles of an entity body's Stale lines, in file order. */
+export declare function staleHandles(body: string, frontmatter: {
+    'staleness-days'?: number;
+}): string[];

package/dist/stale.js

@@ -0,0 +1,43 @@
+// src/stale.ts
+// Stale (see CONTEXT.md): past the entity's `staleness-days` without
+// movement. An open next action is stale when unticked that long since its
+// added day; an undated one is stale. Ages count local days (src/dates.ts).
+import { localDay } from './dates.js';
+import { getActionItems } from './document.js';
+/** The threshold an entity without `staleness-days` gets. */
+export const DEFAULT_STALENESS_DAYS = 14;
+/** A YYYY-MM-DD day as a whole day count, so differences ignore DST. */
+const dayNumber = (day) => {
+    const [y, m, d] = day.split('-').map(Number);
+    return Date.UTC(y, m - 1, d) / 86_400_000;
+};
+/** The entity side of the rule, as SQL over an index row `i` with `@today`
+ * bound to localDay(): whole days from its last-touched day to today.
+ * julianday of two bare YYYY-MM-DD days differs by exactly `dayNumber`'s
+ * difference, so entities and their actions count the same days. */
+export const ENTITY_AGE_DAYS_SQL = 'CAST(julianday(@today) - julianday(i.last_touched) AS INTEGER)';
+/** An entity row is stale when its age is past its threshold, not equal to
+ * it — `actionAge`'s rule. */
+export const ENTITY_STALE_SQL = `${ENTITY_AGE_DAYS_SQL} > COALESCE(i.staleness_days, ${DEFAULT_STALENESS_DAYS})`;
+/** How old an action added on `added` is today, and whether that is past
+ * `stalenessDays`: older than the threshold, not equal to it. */
+export function actionAge(added, stalenessDays, today = localDay()) {
+    if (added === null)
+        return { added, age_days: null, stale: true };
+    const age_days = dayNumber(today) - dayNumber(added);
+    return { added, age_days, stale: age_days > stalenessDays };
+}
+/** An entity's threshold: its `staleness-days`, else the default. */
+export function stalenessDaysOf(frontmatter) {
+    return frontmatter['staleness-days'] ?? DEFAULT_STALENESS_DAYS;
+}
+/** An entity body's Next Actions in file order, each open line aged against
+ * the entity's threshold. */
+export function agedActions(body, frontmatter) {
+    const days = stalenessDaysOf(frontmatter);
+    return getActionItems(body).map(item => item.handle === undefined ? { text: item.text } : { handle: item.handle, text: item.text, ...actionAge(item.added, days) });
+}
+/** The Handles of an entity body's Stale lines, in file order. */
+export function staleHandles(body, frontmatter) {
+    return agedActions(body, frontmatter).flatMap(a => 'handle' in a && a.stale ? [a.handle] : []);
+}

package/dist/stopwords.d.ts

@@ -0,0 +1,6 @@
+export declare const STOPWORDS: ReadonlySet<string>;
+/** Lowercased words with stopwords dropped. `stem` also strips a plural `s`,
+ * so `launchpads` and `launchpad` are one word. */
+export declare function tokenize(text: string, { stem }?: {
+    stem?: boolean;
+}): string[];

package/dist/stopwords.js

@@ -0,0 +1,25 @@
+// src/stopwords.ts
+// Words too common to tell two texts apart: dropped from full-text search
+// terms (db.ts) and, through `tokenize`, from the words the Near-match rule
+// (near-match.ts) and the read-miss closest slugs (closest.ts) compare.
+export const STOPWORDS = new Set([
+    'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of',
+    'with', 'by', 'from', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+    'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could', 'should',
+    'may', 'might', 'can', 'shall', 'not', 'no', 'nor', 'so', 'if', 'then', 'than',
+    'that', 'this', 'these', 'those', 'it', 'its', 'my', 'your', 'his', 'her',
+    'our', 'their', 'what', 'which', 'who', 'whom', 'how', 'when', 'where', 'why',
+    'all', 'each', 'every', 'both', 'few', 'more', 'most', 'some', 'any', 'such',
+    'about', 'into', 'over', 'after', 'before',
+    'work', 'works', 'working', 'use', 'using', 'used', 'get', 'got', 'make', 'made',
+    'need', 'want', 'like', 'just', 'also', 'still', 'already', 'very', 'much',
+]);
+/** Lowercased words with stopwords dropped. `stem` also strips a plural `s`,
+ * so `launchpads` and `launchpad` are one word. */
+export function tokenize(text, { stem = false } = {}) {
+    const words = text
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .filter(w => w && !STOPWORDS.has(w));
+    return stem ? words.map(w => (w.length > 3 && w.endsWith('s') && !w.endsWith('ss') ? w.slice(0, -1) : w)) : words;
+}