hafez 1.3.0 → 2.0.0

package/dist/knowledge-index.d.ts

@@ -1,3 +1,25 @@
+/** One indexed document, as the SQLite index can hand it over. index.md needs
+ * nothing the index does not already hold, so a regeneration reads rows
+ * instead of re-reading and re-parsing every file in the vault. Declared here
+ * (not in db.ts) to keep the module edge pointing one way: db.ts already
+ * imports from this file. */
+export interface VaultIndexRow {
+    slug: string;
+    kind: 'entity' | 'knowledge';
+    name: string;
+    type: string | null;
+    status: string | null;
+    confidence: string | null;
+    description: string | null;
+    domain: string[];
+    body: string;
+}
 /** Ensure every generated local-only artifact is covered by .git/info/exclude. */
 export declare function ensureLocalExclude(vaultPath: string): void;
-export declare function generateVaultIndex(vaultPath: string): void;
+/** Regenerate the vault-root index.md.
+ *
+ * `rows` is the SQLite index's view of the vault — every mutation refreshes
+ * those rows anyway, so passing them avoids a second full-vault read for the
+ * same content. Omitting them (standalone/one-off use) falls back to reading
+ * the files directly. */
+export declare function generateVaultIndex(vaultPath: string, rows?: VaultIndexRow[]): void;

package/dist/knowledge-index.js

@@ -2,10 +2,28 @@
 // Generates the vault-root index.md covering entities (grouped by status) and
 // knowledge (grouped by domain) — local-only, auto-regenerated on every entity/knowledge write.
 import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from 'fs';
-import { join, basename } from 'path';
+import { join, basename, resolve } from 'path';
 import { parseFilePath, scanVaultDir, kindDir } from './vault.js';
 import { deriveSummary } from './document.js';
 import { ENTITY_STATUSES } from './contracts.js';
+/** Index rows in the shape the renderer below expects — the same
+ * {slug, fm, body} triple scanParsed produces from disk. */
+function fromRows(rows, kind) {
+    return rows
+        .filter(r => r.kind === kind)
+        .map(r => ({
+        slug: r.slug,
+        body: r.body,
+        fm: {
+            name: r.name,
+            type: r.type ?? undefined,
+            status: r.status ?? undefined,
+            confidence: r.confidence ?? undefined,
+            description: r.description ?? undefined,
+            domain: r.domain,
+        },
+    }));
+}
 function truncate(s) {
     return s.length > 100 ? s.slice(0, 97) + '...' : s;
 }
@@ -38,11 +56,42 @@ function scanParsed(dir) {
  * show up in the user's `git status`, but forcing a tracked .gitignore entry
  * would dirty their vault — so they go into .git/info/exclude instead. */
 const LOCAL_EXCLUDES = ['/index.md', '/.hafez.db', '/.hafez.db-shm', '/.hafez.db-wal'];
+/** Locate the git directory that owns `info/exclude` for this vault.
+ * `.git` is a directory in a normal clone, but a *gitfile* (`gitdir: <path>`)
+ * in a linked worktree or submodule — treating that file as "not a repo" is
+ * what let index.md and .hafez.db pollute `git status` there. Git reads
+ * `info/exclude` from the COMMON dir, so for a linked worktree the pointed-at
+ * per-worktree dir is one more hop from the answer: its `commondir` file names
+ * the shared dir (writing the exclude in the per-worktree dir has no effect).
+ * Returns null when the vault is not a git repo at all. */
+function resolveExcludeGitDir(vaultPath) {
+    const dotGit = join(vaultPath, '.git');
+    if (!existsSync(dotGit))
+        return null;
+    const stat = statSync(dotGit);
+    if (stat.isDirectory())
+        return dotGit;
+    if (!stat.isFile())
+        return null;
+    const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync(dotGit, 'utf-8'));
+    if (!pointer)
+        return null;
+    const gitDir = resolve(vaultPath, pointer[1].trim());
+    if (!existsSync(gitDir))
+        return null;
+    const commonDirFile = join(gitDir, 'commondir');
+    if (existsSync(commonDirFile)) {
+        const commonDir = resolve(gitDir, readFileSync(commonDirFile, 'utf-8').trim());
+        if (existsSync(commonDir))
+            return commonDir;
+    }
+    return gitDir;
+}
 /** Ensure every generated local-only artifact is covered by .git/info/exclude. */
 export function ensureLocalExclude(vaultPath) {
     try {
-        const gitDir = join(vaultPath, '.git');
-        if (!existsSync(gitDir) || !statSync(gitDir).isDirectory())
+        const gitDir = resolveExcludeGitDir(vaultPath);
+        if (!gitDir)
             return;
         const excludePath = join(gitDir, 'info', 'exclude');
         const existing = existsSync(excludePath) ? readFileSync(excludePath, 'utf-8') : '';
@@ -56,17 +105,24 @@ export function ensureLocalExclude(vaultPath) {
     }
     catch { /* best effort — never fail a vault write over ignore hygiene */ }
 }
-export function generateVaultIndex(vaultPath) {
+/** Regenerate the vault-root index.md.
+ *
+ * `rows` is the SQLite index's view of the vault — every mutation refreshes
+ * those rows anyway, so passing them avoids a second full-vault read for the
+ * same content. Omitting them (standalone/one-off use) falls back to reading
+ * the files directly. */
+export function generateVaultIndex(vaultPath, rows) {
     const entitiesDir = join(vaultPath, kindDir('entity'));
     const knowledgeDir = join(vaultPath, kindDir('knowledge'));
     const hasEntities = existsSync(entitiesDir);
     const hasKnowledge = existsSync(knowledgeDir);
     if (!hasEntities && !hasKnowledge)
         return;
+    const docsFor = (kind, dir) => rows ? fromRows(rows, kind) : scanParsed(dir);
     const lines = ['# Vault Index', '', '> Auto-generated by hafez. Do not edit manually.', ''];
     if (hasEntities) {
         const byStatus = new Map();
-        for (const { slug, fm, body } of scanParsed(entitiesDir)) {
+        for (const { slug, fm, body } of docsFor('entity', entitiesDir)) {
             const status = fm.status ?? 'active';
             const list = byStatus.get(status) ?? [];
             list.push({ slug, name: fm.name, summary: truncate(deriveSummary('entity', fm, body)), suffix: fm.type ?? 'entity' });
@@ -92,7 +148,7 @@ export function generateVaultIndex(vaultPath) {
     }
     if (hasKnowledge) {
         const entries = [];
-        for (const { slug, fm, body } of scanParsed(knowledgeDir)) {
+        for (const { slug, fm, body } of docsFor('knowledge', knowledgeDir)) {
             entries.push({
                 slug,
                 name: fm.name,

package/dist/merge.d.ts

@@ -1 +1 @@
-export declare function mergeVaultContent(remote: string, local: string): string;
+export declare function mergeVaultContent(remote: string, local: string, kind: 'entity' | 'knowledge' | 'session'): string;

package/dist/merge.js

@@ -1,14 +1,13 @@
 // src/merge.ts
-import { parseContent, serializeFile } from './vault.js';
-import { parseSessionLogHeading, splitStructural } from './document.js';
+import { parseContent, serializeFile, ARRAY_FIELDS } from './vault.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'];
 // Fields that are numeric counters — max wins
 const COUNT_FIELDS = ['reinforcement-count', 'staleness-days'];
-// Fields that are always arrays — union with dedup
-const ARRAY_FIELDS_UNCAPPED = ['tags', 'domain', 'related'];
-export function mergeVaultContent(remote, local) {
+// Array fields (vault.ARRAY_FIELDS — the same set parsing coerces) union with dedup
+export function mergeVaultContent(remote, local, kind) {
     const r = parseContent(remote);
     const l = parseContent(local);
     // Scalar policy: the side with the newer last-touched wins; local on tie.
@@ -16,7 +15,18 @@ export function mergeVaultContent(remote, local) {
     // array/date/count frontmatter fields are always unioned regardless.
     const localWins = String(l.frontmatter?.['last-touched'] ?? '') >= String(r.frontmatter?.['last-touched'] ?? '');
     const fm = mergeFrontmatter(r.frontmatter, l.frontmatter, localWins);
-    const body = mergeBody(r.body, l.body, localWins);
+    // The Document binds by kind — the same binding every write path uses (see
+    // DocContext), so a section this merge preserves stays structural for the
+    // next update too. The two sides come from divergent histories whose type
+    // may differ (a promote race leaves one side 'capture' and the other
+    // 'project'); the kind-level set keeps every same-kind section structural,
+    // while cross-KIND headings (a session-only ## Decisions quoted in an
+    // entity Brief) are not boundaries. Known residual: a same-kind heading
+    // quoted at line start in one side's section splits at that false boundary
+    // and can survive the merge as its own section — the fix is fence/quote
+    // awareness in Document's splitter, not a narrower binding here.
+    const doc = documentFor({ kind });
+    const body = mergeBody(doc, r.body, l.body, localWins);
     return serializeFile(fm, body);
 }
 function mergeFrontmatter(remote, local, localWins) {
@@ -39,7 +49,7 @@ function mergeFrontmatter(remote, local, localWins) {
             merged[key] = r;
     }
     // Array fields: union
-    for (const key of ARRAY_FIELDS_UNCAPPED) {
+    for (const key of ARRAY_FIELDS) {
         merged[key] = unionArrays(remote[key], local[key]);
         if (merged[key].length === 0)
             delete merged[key];
@@ -47,20 +57,21 @@ function mergeFrontmatter(remote, local, localWins) {
     return merged;
 }
 function unionArrays(a, b) {
-    // Local (b) items first so they survive cap truncation
+    // Local (b) items first: nothing is truncated, but the local side's order is
+    // the one the user last saw, so it stays the order they get back.
     const arrA = Array.isArray(a) ? a : a ? [a] : [];
     const arrB = Array.isArray(b) ? b : b ? [b] : [];
     return [...new Set([...arrB, ...arrA])];
 }
 // --- Body merge ---
-function mergeBody(remoteBody, localBody, localWins) {
+function mergeBody(doc, remoteBody, localBody, localWins) {
     if (remoteBody === localBody)
         return localBody;
     // Structural split (see document.ts): sections are atomic — a user ##
     // heading inside a Brief or a session-log entry body stays with its
     // section instead of being split out and merged under its own policy.
-    const remote = splitStructural(remoteBody);
-    const local = splitStructural(localBody);
+    const remote = doc.splitStructural(remoteBody);
+    const local = doc.splitStructural(localBody);
     // Build merged sections starting from local (local section order is canonical)
     const localHeadings = new Set(local.sections.map(s => s.heading));
     const mergedSections = [];
@@ -90,10 +101,16 @@ function mergeBody(remoteBody, localBody, localWins) {
             mergedSections.push(rs);
         }
     }
-    // Reassemble
-    const preamble = localWins
-        ? (local.preamble || remote.preamble)
-        : (remote.preamble || local.preamble);
+    // Reassemble. A preamble that is itself a session-log entry stream is
+    // append-only content living outside any heading — the archive-log files
+    // under entities/archive/ are exactly this shape. Merging those by the
+    // scalar wins policy drops one machine's archived entries wholesale, so
+    // union them by the same entry policy the Session Log section uses.
+    const preamble = isLogEntryStream(remote.preamble) && isLogEntryStream(local.preamble)
+        ? mergeSessionLogs(remote.preamble, local.preamble)
+        : localWins
+            ? (local.preamble || remote.preamble)
+            : (remote.preamble || local.preamble);
     const parts = [preamble, ...mergedSections.map(s => `## ${s.heading}\n\n${s.content}`)].filter(Boolean);
     return parts.join('\n\n');
 }
@@ -111,6 +128,12 @@ function mergeAppendOnlyLines(remoteContent, localContent) {
         return localContent;
     return [...localLines, ...remoteOnly].join('\n');
 }
+/** True when a block is nothing but session-log entries — it starts with an
+ *  entry heading, so splitLogEntries drops no leading prose. */
+function isLogEntryStream(text) {
+    const first = text.trim().split('\n')[0];
+    return first !== '' && parseSessionLogHeading(first) !== null;
+}
 function mergeSessionLogs(remoteContent, localContent) {
     const remoteEntries = parseLogEntries(remoteContent);
     const localEntries = parseLogEntries(localContent);
@@ -128,64 +151,75 @@ function mergeSessionLogs(remoteContent, localContent) {
     return merged.map(e => e.raw).join('\n\n');
 }
 function parseLogEntries(content) {
-    const entries = [];
-    const blocks = content.split(/\n(?=### \d{4}-\d{2}-\d{2})/);
-    for (const block of blocks) {
-        const trimmed = block.trim();
-        if (!trimmed)
-            continue;
-        const firstLine = trimmed.split('\n')[0];
-        const parsed = parseSessionLogHeading(firstLine);
-        if (parsed) {
-            entries.push({
-                key: `${parsed.date}|${parsed.agent}|${parsed.type}`,
-                date: parsed.date,
-                raw: trimmed,
-            });
-        }
-    }
-    return entries;
+    // Document owns entry block splitting; the identity key and dedup/sort
+    // policy stay here — merge semantics, not document structure.
+    //
+    // Identity is the entry's whole content. Date+agent+type is not an identity:
+    // two machines each running a digest on the same day produce two entries with
+    // the same heading and different bodies, and keying on the heading collapses
+    // them to one — the other machine's session history is gone. Entries the two
+    // sides share came from the same commit, so they are byte-identical and still
+    // dedup.
+    return splitLogEntries(content).map(raw => {
+        const parsed = parseSessionLogHeading(raw.split('\n')[0]);
+        return { key: raw, date: parsed.date, raw };
+    });
 }
 function mergeNextActions(remoteContent, localContent) {
-    const remoteItems = parseActionItems(remoteContent);
-    const localItems = parseActionItems(localContent);
-    // Build merged set: start with local items
-    const seen = new Set();
-    const merged = [];
-    // Add all local items
-    for (const item of localItems) {
-        seen.add(item.text);
-        merged.push(item);
-    }
-    // Add remote items not in local
-    for (const item of remoteItems) {
-        if (!seen.has(item.text)) {
-            seen.add(item.text);
-            merged.push(item);
-        }
-        else {
-            // If remote has it checked but local has it unchecked, upgrade to checked
-            const existing = merged.find(m => m.text === item.text);
-            if (existing && item.checked && !existing.checked) {
-                existing.checked = true;
-            }
+    const remote = parseActionItems(remoteContent);
+    const local = parseActionItems(localContent);
+    // 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 => [stripActionStamp(i.text), i]));
+    for (const item of remote.items) {
+        const existing = byText.get(stripActionStamp(item.text));
+        if (!existing) {
+            merged.push({ ...item, notes: [...item.notes] });
+            byText.set(stripActionStamp(item.text), merged[merged.length - 1]);
+            continue;
         }
+        // Checked on either side means done
+        if (item.checked)
+            existing.checked = true;
+        // Union the item's own notes/sub-bullets — they are authored content, not
+        // re-derivable from the checkbox line
+        existing.notes.push(...unionLines(item.notes, existing.notes));
+    }
+    const lines = [...local.preamble, ...unionLines(remote.preamble, local.preamble)];
+    for (const item of merged) {
+        lines.push(`- [${item.checked ? 'x' : ' '}] ${item.text}`);
+        lines.push(...item.notes);
     }
-    return merged.map(i => `- [${i.checked ? 'x' : ' '}] ${i.text}`).join('\n');
+    return lines.join('\n').replace(/\n+$/, '');
 }
+/** Lines of `from` not already present in `into` (blank lines only from `into`). */
+function unionLines(from, into) {
+    const seen = new Set(into.map(l => l.trim()).filter(Boolean));
+    return from.filter(l => l.trim() && !seen.has(l.trim()));
+}
+/**
+ * Split a Next Actions section into its leading non-item lines and its items,
+ * each item carrying the lines that follow it (indented sub-bullets, notes)
+ * until the next checkbox. Non-checkbox lines are authored content — parsing
+ * checkbox lines alone and re-rendering from them deletes everything else.
+ * `- [X]` is the same as `- [x]`: a completed action, not an unknown line.
+ */
 function parseActionItems(content) {
+    const preamble = [];
     const items = [];
     for (const line of content.split('\n')) {
-        const unchecked = line.match(/^- \[ \] (.+)$/);
-        if (unchecked) {
-            items.push({ checked: false, text: unchecked[1] });
-            continue;
+        const match = line.match(/^- \[([ xX])\] (.+)$/);
+        if (match) {
+            items.push({ checked: match[1].toLowerCase() === 'x', text: match[2], notes: [] });
         }
-        const checked = line.match(/^- \[x\] (.+)$/);
-        if (checked) {
-            items.push({ checked: true, text: checked[1] });
-            continue;
+        else if (items.length === 0) {
+            preamble.push(line);
+        }
+        else {
+            items[items.length - 1].notes.push(line);
         }
     }
-    return items;
+    return { preamble, items };
 }

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/schema.js

@@ -1,5 +1,5 @@
 // src/schema.ts
-import { ENTITY_TYPES, ENTITY_STATUSES, CONFIDENCE_LEVELS, SESSION_LOG_TYPES, VALID_SUBTYPES, } from './contracts.js';
+import { ENTITY_TYPES, ENTITY_STATUSES, CONFIDENCE_LEVELS, SESSION_LOG_TYPES, VALID_SUBTYPES, PLAN_STATUSES, } from './contracts.js';
 export function validateEntityFrontmatter(fm) {
     const errors = [];
     if (!fm.name || typeof fm.name !== 'string')
@@ -35,9 +35,9 @@ export function validateKnowledgeSubtype(fm) {
     if (fm.subtype && !VALID_SUBTYPES.includes(fm.subtype)) {
         errors.push(`invalid subtype: ${fm.subtype} (expected: ${VALID_SUBTYPES.join(', ')})`);
     }
-    // Plan-specific: status must be active or done
-    if (fm.subtype === 'plan' && fm.status && !['active', 'done'].includes(fm.status)) {
-        errors.push(`invalid plan status: ${fm.status} (expected: active, done)`);
+    // Plan-specific: status must be one of the plan lifecycle statuses
+    if (fm.subtype === 'plan' && fm.status && !PLAN_STATUSES.includes(fm.status)) {
+        errors.push(`invalid plan status: ${fm.status} (expected: ${PLAN_STATUSES.join(', ')})`);
     }
     return errors;
 }

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;
+}