@jbarket/loomai 0.8.0 → 0.9.0

package/dist/ui/core.js

@@ -1,27 +1,22 @@
 /**
- * loom's own sections for the UI: what only loom knows. Read-only views over
- * the stores (top of mind, the episode tape, pending proposals, people),
- * assembled from the same functions the identity payload and the MCP-App
- * widgets use. Nothing here writes.
+ * loom's own pages: what only loom knows. Home (the tape, top of mind, the
+ * people who need a look), Mind (every memory's heat and why), one memory,
+ * People and one person, plus the actions on them (archive a memory, ratify
+ * or reject a proposal). Built in the same vocabulary the pieces use, so one
+ * renderer draws everything. Nothing here names a piece.
  */
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
-import { digestData } from '../backends/salience.js';
-import { episodeRows, tapeClock } from '../backends/episodes.js';
-import { listProposals } from '../backends/proposals.js';
-import { listPeople } from '../tools/person.js';
-const TOP_OF_MIND = 12;
+import { listProposals, rejectProposal, ratifyProposal, UnknownProposalError } from '../backends/proposals.js';
+import { fieldState } from '../backends/people.js';
+import { listPeople, readPerson } from '../tools/person.js';
+import { archive } from '../tools/archive.js';
+import { heatList, memoriesAbout, memoryByRef, tapeRows } from './data.js';
+import { validPath } from './vocab.js';
 const TAPE_HOURS = 24;
-const TAPE_SHOWN = 20;
-function whereOf(metadata, project) {
-    try {
-        const meta = JSON.parse(metadata || '{}');
-        if (typeof meta.where === 'string' && meta.where.trim())
-            return meta.where.trim();
-    }
-    catch { /* fall through */ }
-    return project?.trim() || '?';
-}
+const TAPE_MAX_HOURS = 24 * 7;
+const MIND_SHOWN = 40;
+const HOME_MIND = 5;
 /** loom's zone (LOOM_TIMEZONE, then TZ), and one that Intl accepts: a bad value never breaks the page. */
 export function uiTimeZone() {
     for (const z of [process.env.LOOM_TIMEZONE, process.env.TZ, 'America/Chicago']) {
@@ -35,9 +30,6 @@ export function uiTimeZone() {
     }
     return 'UTC';
 }
-function tierTone(tier) {
-    return tier === 'cold' ? 'muted' : undefined;
-}
 /** The agent's name: IDENTITY.md's first heading, else the context dir's name. */
 export function agentName(contextDir) {
     try {
@@ -48,93 +40,425 @@ export function agentName(contextDir) {
     catch { /* no identity file */ }
     return contextDir.split('/').filter(Boolean).pop() ?? 'loom';
 }
-export function coreSections(contextDir, opts = {}) {
-    const timeZone = opts.timeZone ?? uiTimeZone();
-    const digest = digestData(contextDir, TOP_OF_MIND);
-    const episodes = episodeRows(contextDir, { hours: TAPE_HOURS, nowMs: opts.nowMs });
-    const pending = listProposals(contextDir).filter((p) => p.status === 'pending');
+function parts(iso, tz) {
+    const d = new Date(iso);
+    const f = (o) => new Intl.DateTimeFormat('en-US', { timeZone: tz, ...o }).format(d);
+    return {
+        day: f({ year: 'numeric', month: '2-digit', day: '2-digit' }),
+        weekday: f({ weekday: 'short' }),
+        date: f({ month: 'short', day: 'numeric' }),
+        time: f({ hour: 'numeric', minute: '2-digit' }).toLowerCase().replace(/\s/g, ' '),
+        hour: f({ hour: 'numeric' }).toLowerCase(),
+    };
+}
+/** "Sat Oct 24, 12:09 pm" */
+export function when(iso, tz) {
+    if (!iso || Number.isNaN(Date.parse(iso)))
+        return 'never';
+    const p = parts(iso, tz);
+    return `${p.weekday} ${p.date}, ${p.time}`;
+}
+/** "today 12:09 pm", "yesterday", "Oct 19" */
+function ago(iso, tz, nowMs) {
+    if (!iso || Number.isNaN(Date.parse(iso)))
+        return 'never';
+    const p = parts(iso, tz);
+    const today = parts(new Date(nowMs).toISOString(), tz).day;
+    const yesterday = parts(new Date(nowMs - 86_400_000).toISOString(), tz).day;
+    if (p.day === today)
+        return `today ${p.time}`;
+    if (p.day === yesterday)
+        return `yesterday ${p.time}`;
+    return p.date;
+}
+const heatTone = (h) => (h >= 0.6 ? 'warn' : h < 0.2 ? 'muted' : undefined);
+/** The plain-language reason a memory has the heat it has. */
+function why(m, tz, nowMs, people) {
+    const written = m.updated ? `Edited ${ago(m.updated, tz, nowMs)}.` : `Written ${ago(m.created, tz, nowMs)}.`;
+    const recalled = m.recallHeat >= 0.01
+        ? ` Being recalled adds ${m.recallHeat.toFixed(2)} (last ${ago(m.lastAccessed, tz, nowMs)}): the top result of a recall adds the most, an incidental one little.`
+        : m.lastAccessed ? '' : ' Never recalled.';
+    const source = m.recallHeat > m.writtenHeat ? 'recall' : 'when it was written';
+    const decay = ` ${m.category[0].toUpperCase()}${m.category.slice(1)} memories cool by half every ${m.halfLifeDays} days; it's at ${m.heat.toFixed(2)} now, from ${source}.`;
+    const where = m.inDigest ? ' That puts it in what I wake up holding.' : ' That\'s below what I wake up holding.';
+    const about = m.person
+        ? ` It's about ${people.get(m.person) ?? m.person}, but nothing limits it to conversations with them.`
+        : '';
+    return `${written}${recalled}${decay}${where}${about}`;
+}
+function memoryDetails(m, tz, nowMs, people) {
+    return {
+        type: 'details',
+        summary: m.title,
+        meta: `${m.category} · ${m.heat.toFixed(2)}${m.inDigest ? ' · at wake' : ''}`,
+        blocks: [
+            { type: 'text', text: why(m, tz, nowMs, people) },
+            {
+                type: 'kv',
+                items: [
+                    { label: 'heat now', value: m.heat.toFixed(2) },
+                    { label: 'from writing', value: m.writtenHeat.toFixed(2) },
+                    { label: 'from recall', value: m.recallHeat.toFixed(2) },
+                    ...(Math.abs(m.stored - m.heat) > 0.05 ? [{ label: 'stored (lane)', value: m.stored.toFixed(2) }] : []),
+                    { label: 'half-life', value: `${m.halfLifeDays} days` },
+                    { label: 'sourcing', value: m.sourcing ?? 'unknown' },
+                    ...(m.project ? [{ label: 'project', value: m.project }] : []),
+                    ...(m.person ? [{ label: 'about', value: people.get(m.person) ?? m.person, page: personPage(m.person) }] : []),
+                ],
+            },
+            ...(memoryPage(m.ref) ? [{ type: 'link', text: 'Open memory', page: memoryPage(m.ref) }] : []),
+        ],
+    };
+}
+function memoryPage(ref) {
+    const p = `memory/${ref}`;
+    return validPath(p) ? p : undefined;
+}
+function personPage(slug) {
+    const p = `people/${slug}`;
+    return validPath(p) ? p : undefined;
+}
+function peopleNames(contextDir) {
+    return new Map(listPeople(contextDir).map((p) => [p.slug, p.name]));
+}
+function surfaceOf(where) {
+    return where.split(/[:/]/)[0] || '?';
+}
+/** Home: the tape is the page. Top of mind and people sit beside it. */
+export function homePage(contextDir, query, opts = {}) {
+    const tz = opts.timeZone ?? uiTimeZone();
+    const nowMs = opts.nowMs ?? Date.now();
+    const hours = Math.min(TAPE_MAX_HOURS, Math.max(TAPE_HOURS, Number.parseInt(query.hours ?? '', 10) || TAPE_HOURS));
+    const all = tapeRows(contextDir, hours, nowMs);
+    const surfaces = [...new Set(all.map((e) => surfaceOf(e.where)))].sort();
+    const pick = query.where && surfaces.includes(query.where) ? query.where : '';
+    const tape = pick ? all.filter((e) => surfaceOf(e.where) === pick) : all;
+    // Group by the hour each happened in, newest first.
+    const groups = [];
+    const today = parts(new Date(nowMs).toISOString(), tz).day;
+    for (const e of tape) {
+        const p = parts(e.created, tz);
+        const label = p.day === today ? p.hour : `${p.weekday} ${p.hour}`;
+        const last = groups[groups.length - 1];
+        if (last && last.label === label)
+            last.items.push(e);
+        else
+            groups.push({ label, items: [e] });
+    }
+    const tapeBlocks = [];
+    if (surfaces.length > 1) {
+        tapeBlocks.push({ type: 'filters', param: 'where', options: [{ value: '', label: 'Everywhere' }, ...surfaces.map((s) => ({ value: s, label: s }))] });
+    }
+    for (const g of groups) {
+        tapeBlocks.push({ type: 'text', text: g.label, tone: 'muted' });
+        tapeBlocks.push({
+            type: 'list',
+            items: g.items.map((e) => ({ text: e.title, meta: `${parts(e.created, tz).time} · ${e.where}`, page: memoryPage(e.ref) })),
+        });
+    }
+    if (!tape.length)
+        tapeBlocks.push({ type: 'text', text: pick ? `Nothing from ${pick} in the last ${hours}h.` : `Nothing in the last ${hours}h.`, tone: 'muted' });
+    if (hours < TAPE_MAX_HOURS) {
+        tapeBlocks.push({ type: 'link', text: 'Show earlier', page: `?hours=${Math.min(TAPE_MAX_HOURS, hours * 2)}${pick ? `&where=${pick}` : ''}` });
+    }
+    const heat = heatList(contextDir, { limit: HOME_MIND, nowMs });
     const people = listPeople(contextDir);
+    const attention = people.filter((p) => p.stale || p.unverified || p.memories_since_synthesis);
+    const sources = surfaces.length;
     const sections = [
-        {
-            id: 'overview',
-            title: 'Overview',
-            blocks: [{
-                    type: 'stats',
-                    items: [
-                        { label: 'memories', value: String(digest?.total ?? 0) },
-                        { label: `episodes, last ${TAPE_HOURS}h`, value: String(episodes.length) },
-                        { label: 'proposals pending', value: String(pending.length), tone: pending.length ? 'warn' : undefined },
-                        { label: 'people', value: String(people.length) },
-                    ],
-                }],
-        },
         {
             id: 'tape',
-            title: `Last ${TAPE_HOURS}h`,
-            blocks: episodes.length
-                ? [
-                    {
-                        type: 'list',
-                        items: [...episodes].reverse().slice(0, TAPE_SHOWN).map((e) => ({
-                            text: e.title,
-                            meta: `${tapeClock(e.created, timeZone)} · ${whereOf(e.metadata, e.project)}`,
-                        })),
-                    },
-                    ...(episodes.length > TAPE_SHOWN
-                        ? [{ type: 'text', text: `and ${episodes.length - TAPE_SHOWN} earlier` }]
-                        : []),
-                ]
-                : [{ type: 'text', text: 'No episodes in the last day.' }],
+            title: 'What\'s happening',
+            blocks: [
+                { type: 'text', text: `${all.length} thing${all.length === 1 ? '' : 's'} in the last ${hours === 24 ? 'day' : `${hours}h`}, from ${sources} place${sources === 1 ? '' : 's'}.`, tone: 'muted' },
+                ...tapeBlocks,
+            ],
         },
         {
-            id: 'top-of-mind',
-            title: 'Top of mind',
-            blocks: digest && digest.atoms.length
+            id: 'mind',
+            title: 'On my mind',
+            side: true,
+            blocks: heat.rows.length
+                ? [{ type: 'list', items: heat.rows.map((m) => ({ text: m.title, meta: `${m.category} · ${m.heat.toFixed(2)}`, page: memoryPage(m.ref) })) },
+                    { type: 'link', text: 'Why these?', page: 'mind' }]
+                : [{ type: 'text', text: 'Nothing hot yet.', tone: 'muted' }],
+        },
+    ];
+    if (people.length) {
+        sections.push({
+            id: 'people',
+            title: 'People',
+            side: true,
+            blocks: attention.length
                 ? [{
                         type: 'list',
-                        items: digest.atoms.map((a) => ({ text: a.title, meta: `${a.category} · ${a.tier}`, tone: tierTone(a.tier) })),
-                    }]
-                : [{ type: 'text', text: 'Nothing hot yet.' }],
+                        items: attention.map((p) => ({
+                            text: p.name,
+                            meta: [
+                                p.memories_since_synthesis ? `${p.memories_since_synthesis} new memor${p.memories_since_synthesis === 1 ? 'y' : 'ies'} not on the card` : '',
+                                p.stale ? `${p.stale} stale` : '',
+                                p.unverified ? `${p.unverified} unverified` : '',
+                            ].filter(Boolean).join(' · '),
+                            tone: 'warn',
+                            page: personPage(p.slug),
+                        })),
+                    },
+                    { type: 'link', text: `All ${people.length} cards`, page: 'people' }]
+                : [{ type: 'text', text: `All ${people.length} cards are current.`, tone: 'muted' }, { type: 'link', text: 'Open People', page: 'people' }],
+        });
+    }
+    return {
+        tile: {
+            label: 'Memory',
+            value: heat.total.toLocaleString('en-US'),
+            detail: `${all.length} episodes today · ${people.length} people`,
+            page: 'mind',
         },
-    ];
+        page: { title: 'Home', sections },
+    };
+}
+// ─── Mind ────────────────────────────────────────────────────────────────────
+function mindPage(contextDir, query, tz, nowMs) {
+    const categories = ['user', 'feedback', 'project', 'self', 'reference', 'pursuit'];
+    const category = categories.includes(query.category ?? '') ? query.category : undefined;
+    const list = heatList(contextDir, { limit: MIND_SHOWN, category, nowMs });
+    const names = peopleNames(contextDir);
+    const pending = listProposals(contextDir).filter((p) => p.status === 'pending');
+    const atWake = list.rows.filter((m) => m.inDigest);
+    const below = list.rows.filter((m) => !m.inDigest);
+    const sections = [];
     if (pending.length) {
         sections.push({
             id: 'proposals',
-            title: 'Proposals waiting',
+            title: `${pending.length} proposal${pending.length === 1 ? '' : 's'} waiting`,
+            blocks: [
+                { type: 'text', text: 'Drafted memories that aren\'t real until they\'re ratified. Recall can\'t see them.', tone: 'muted' },
+                ...pending.map((p) => ({
+                    type: 'details',
+                    summary: p.title ?? '(untitled)',
+                    meta: `#${p.id} · ${p.category ?? '?'}${p.source ? ` · from ${p.source}` : ''} · ${ago(p.created, tz, nowMs)}`,
+                    blocks: [
+                        { type: 'text', text: p.content ?? '' },
+                        { type: 'buttons', items: [
+                                { action: 'ratify', label: 'Ratify', tone: 'primary', fields: { id: String(p.id) } },
+                                { action: 'reject', label: 'Reject', tone: 'danger', fields: { id: String(p.id) } },
+                            ] },
+                    ],
+                })),
+            ],
+        });
+    }
+    sections.push({
+        id: 'filter',
+        blocks: [
+            { type: 'filters', param: 'category', options: [{ value: '', label: 'Everything' }, ...categories.map((c) => ({ value: c, label: c }))] },
+            { type: 'text', text: `${list.total.toLocaleString('en-US')} memories · ${list.inDigest} load at wake · heat is computed from timestamps when it's read`, tone: 'muted' },
+        ],
+    });
+    sections.push({
+        id: 'wake',
+        title: category ? `At wake: ${category}` : 'What I wake up holding',
+        blocks: atWake.length ? atWake.map((m) => memoryDetails(m, tz, nowMs, names)) : [{ type: 'text', text: 'None of these load at wake.', tone: 'muted' }],
+    });
+    if (below.length) {
+        sections.push({
+            id: 'below',
+            title: 'Just below the line',
+            blocks: below.map((m) => memoryDetails(m, tz, nowMs, names)),
+        });
+    }
+    return {
+        title: 'On my mind',
+        intro: 'What I wake up holding. Each memory\'s heat decays by its category\'s half-life and comes back when it\'s recalled or edited. If something here doesn\'t belong, open it and see why.',
+        sections,
+    };
+}
+// ─── One memory ──────────────────────────────────────────────────────────────
+function memoryPageFor(contextDir, ref, tz, nowMs) {
+    const m = memoryByRef(contextDir, ref, nowMs);
+    if (!m)
+        return { title: 'Not found', sections: [] };
+    const names = peopleNames(contextDir);
+    const episode = m.category === 'episode';
+    const main = [
+        { type: 'text', text: m.content },
+        ...(m.person ? [{ type: 'kv', items: [{ label: 'about', value: names.get(m.person) ?? m.person, page: personPage(m.person) }] }] : []),
+        { type: 'buttons', items: [{ action: 'archive', label: 'Archive', tone: 'danger', fields: { ref: m.ref } }] },
+    ];
+    const record = {
+        type: 'kv',
+        items: [
+            { label: 'category', value: m.category },
+            { label: 'written', value: when(m.created, tz) },
+            { label: 'last recalled', value: when(m.lastAccessed, tz) },
+            { label: 'edited', value: when(m.updated, tz) },
+            { label: 'seen', value: `${m.timesSeen} time${m.timesSeen === 1 ? '' : 's'}` },
+            { label: 'sourcing', value: m.sourcing ?? 'unknown' },
+            { label: 'scope', value: m.scope ?? (m.project ? 'project' : 'global') },
+            ...(m.project ? [{ label: 'project', value: m.project }] : []),
+            { label: 'expires', value: m.expiresAt ? when(m.expiresAt, tz) : 'never' },
+            { label: 'ref', value: m.ref },
+        ],
+    };
+    const sections = [{ id: 'memory', blocks: main }];
+    if (!episode) {
+        sections.push({
+            id: 'heat',
+            title: 'Heat',
+            side: true,
+            blocks: [
+                { type: 'stats', items: [{ label: 'now', value: m.heat.toFixed(2), tone: heatTone(m.heat) }, { label: 'half-life', value: `${m.halfLifeDays}d` }] },
+                { type: 'text', text: why(m, tz, nowMs, names), tone: 'muted' },
+            ],
+        });
+    }
+    sections.push({ id: 'record', title: 'Record', side: true, blocks: [record] });
+    return { title: m.title, sections };
+}
+// ─── People ──────────────────────────────────────────────────────────────────
+function value(v) {
+    return Array.isArray(v) ? v.join(', ') : String(v);
+}
+function peoplePage(contextDir) {
+    const people = listPeople(contextDir);
+    const attention = people.filter((p) => p.stale || p.unverified || p.memories_since_synthesis).length;
+    return {
+        title: 'People',
+        intro: 'Who I know, where to reach them, and how they like to be talked to. Each card is a summary of what\'s in memory, with a date on every fact.',
+        sections: [
+            { id: 'counts', blocks: [{ type: 'stats', items: [
+                            { label: 'cards', value: String(people.length) },
+                            { label: 'need a look', value: String(attention), tone: attention ? 'warn' : 'ok' },
+                        ] }] },
+            {
+                id: 'everyone',
+                blocks: people.length
+                    ? [{
+                            type: 'list',
+                            items: people.map((p) => {
+                                const n = p.memories_since_synthesis;
+                                const flag = [n ? `${n} new` : '', p.stale ? `${p.stale} stale` : '', p.unverified ? `${p.unverified} unverified` : ''].filter(Boolean).join(' · ');
+                                return { text: p.name, meta: p.slug, badge: flag || undefined, tone: flag ? 'warn' : undefined, page: personPage(p.slug) };
+                            }),
+                        }]
+                    : [{ type: 'text', text: 'No cards yet.', tone: 'muted' }],
+            },
+        ],
+    };
+}
+function personPageFor(contextDir, slug, tz, nowMs) {
+    let read;
+    try {
+        read = readPerson(contextDir, slug);
+    }
+    catch {
+        return { title: 'Not found', sections: [] };
+    }
+    // A piece can link to someone loom has no card for (it can't know which
+    // cards exist): say so, and show what memory has about them anyway.
+    if (!read.found || !('card' in read)) {
+        const about = memoriesAbout(contextDir, slug, { limit: 8, nowMs });
+        return {
+            title: slug,
+            sections: [
+                { id: 'none', blocks: [{ type: 'callout', text: `There's no person card for ${slug} yet.` }] },
+                ...(about.length ? [{ id: 'memories', title: 'What I remember about them', blocks: [{ type: 'list', items: about.map((m) => ({ text: m.title, meta: ago(m.created, tz, nowMs), page: memoryPage(m.ref) })) }] }] : []),
+            ],
+        };
+    }
+    const card = read.card;
+    const newer = memoriesAbout(contextDir, slug, { since: read.synthesized_at, nowMs });
+    const recent = memoriesAbout(contextDir, slug, { limit: 8, nowMs });
+    const sections = [];
+    if (newer.length) {
+        sections.push({
+            id: 'newer',
+            title: `${newer.length} memor${newer.length === 1 ? 'y is' : 'ies are'} newer than this card`,
+            tone: 'warn',
+            blocks: [{ type: 'list', items: newer.map((m) => ({ text: m.title, meta: ago(m.created, tz, nowMs), page: memoryPage(m.ref) })) }],
+        });
+    }
+    if (card.summary)
+        sections.push({ id: 'summary', blocks: [{ type: 'text', text: card.summary }] });
+    const where = Object.entries(card.where).sort(([a], [b]) => a.localeCompare(b));
+    if (where.length) {
+        sections.push({
+            id: 'where',
+            title: 'Where to reach them',
             blocks: [{
-                    type: 'list',
-                    items: pending.map((p) => ({
-                        text: p.title ?? '(untitled)',
-                        meta: `#${p.id} · ${p.category ?? '?'}${p.source ? ` · ${p.source}` : ''}`,
-                        tone: 'warn',
-                    })),
+                    type: 'table',
+                    columns: ['where', 'value', 'from', 'checked'],
+                    rows: where.map(([k, env]) => {
+                        const s = fieldState(env, nowMs);
+                        return [k, value(env.value), env.source ?? '', s.kind === 'ok' ? `ok, ${ago(env.verified_at ?? null, tz, nowMs)}` : s.kind === 'stale' ? `stale ${s.days}d` : 'unverified'];
+                    }),
                 }],
         });
     }
-    if (people.length) {
-        // Only the cards that need a look: stale or unverified fields, or memories
-        // written since the summary was last synthesized.
-        const attention = people.filter((p) => p.stale || p.unverified || p.memories_since_synthesis);
+    const how = Object.entries(card.how);
+    if (how.length)
+        sections.push({ id: 'how', title: 'How to talk to them', side: true, blocks: [{ type: 'kv', items: how.map(([k, v]) => ({ label: k, value: value(v) })) }] });
+    if (card.may.length) {
         sections.push({
-            id: 'people',
-            title: 'People',
+            id: 'may',
+            title: 'What they\'re cleared for',
+            side: true,
             blocks: [
-                {
-                    type: 'stats',
-                    items: [
-                        { label: 'cards', value: String(people.length) },
-                        { label: 'need a look', value: String(attention.length), tone: attention.length ? 'warn' : 'ok' },
-                    ],
-                },
-                attention.length
-                    ? {
-                        type: 'table',
-                        columns: ['name', 'stale', 'unverified', 'new memories'],
-                        rows: attention.map((p) => [p.name, String(p.stale), String(p.unverified), String(p.memories_since_synthesis)]),
-                    }
-                    : { type: 'text', text: 'Every card is fresh.' },
+                { type: 'list', items: card.may.map((m) => ({ text: m.text, meta: `said by ${m.source}` })) },
+                { type: 'text', text: 'A description of what was agreed. Actual access is set where it\'s enforced, not here.', tone: 'muted' },
             ],
         });
     }
-    return sections;
+    if (recent.length) {
+        sections.push({ id: 'memories', title: 'What I remember about them', blocks: [{ type: 'list', items: recent.map((m) => ({ text: m.title, meta: ago(m.created, tz, nowMs), page: memoryPage(m.ref) })) }] });
+    }
+    sections.push({ id: 'record', side: true, blocks: [{ type: 'kv', items: [
+                    { label: 'slug', value: card.slug },
+                    { label: 'card updated', value: when(read.updated, tz) },
+                    { label: 'summary written', value: when(read.synthesized_at, tz) },
+                ] }] });
+    return { title: card.name, sections };
+}
+// ─── Routing and actions ─────────────────────────────────────────────────────
+/** One of loom's pages by path (not Home), or null when there's no such page. */
+export function corePage(contextDir, path, query, opts = {}) {
+    const tz = opts.timeZone ?? uiTimeZone();
+    const nowMs = opts.nowMs ?? Date.now();
+    if (path === 'mind')
+        return mindPage(contextDir, query, tz, nowMs);
+    if (path === 'people')
+        return peoplePage(contextDir);
+    if (path.startsWith('people/'))
+        return personPageFor(contextDir, path.slice('people/'.length), tz, nowMs);
+    if (path.startsWith('memory/'))
+        return memoryPageFor(contextDir, path.slice('memory/'.length), tz, nowMs);
+    return null;
+}
+/** Run one of loom's own actions from the page. */
+export async function coreAct(contextDir, action, fields) {
+    if (action === 'archive') {
+        const ref = fields.ref ?? '';
+        if (!ref)
+            return { ok: false, message: 'No memory named.' };
+        const out = await archive(contextDir, { ref, note: 'archived from loom\'s page' });
+        return out.startsWith('Memory archived') ? { ok: true, message: 'Archived. It can be restored with memory_restore.', page: 'mind' } : { ok: false, message: out };
+    }
+    if (action === 'ratify' || action === 'reject') {
+        const id = Number.parseInt(fields.id ?? '', 10);
+        if (!Number.isSafeInteger(id) || id <= 0)
+            return { ok: false, message: 'No proposal named.' };
+        try {
+            if (action === 'reject') {
+                return rejectProposal(contextDir, id) ? { ok: true, message: `Proposal #${id} rejected.`, page: 'mind' } : { ok: false, message: `No proposal #${id}.` };
+            }
+            const ref = await ratifyProposal(contextDir, id);
+            return { ok: true, message: `Proposal #${id} is a memory now.`, page: memoryPage(ref.ref) ?? 'mind' };
+        }
+        catch (err) {
+            if (err instanceof UnknownProposalError)
+                return { ok: false, message: `No proposal #${id}.` };
+            return { ok: false, message: err.message };
+        }
+    }
+    return { ok: false, message: `loom has no action "${action}".` };
 }

package/dist/ui/data.d.ts

@@ -0,0 +1,53 @@
+import { type Tier } from '../backends/salience.js';
+export interface MemoryView {
+    ref: string;
+    title: string;
+    category: string;
+    project: string | null;
+    content: string;
+    sourcing: string | null;
+    scope: string | null;
+    created: string;
+    updated: string | null;
+    lastAccessed: string | null;
+    expiresAt: string | null;
+    timesSeen: number;
+    /** The person this memory is about (metadata.person), when tagged. */
+    person: string | null;
+    /** The stored field, refreshed by the consolidation lane. */
+    stored: number;
+    /** Heat right now (heatOf): what the digest uses. */
+    heat: number;
+    /** Its two parts: from being written or edited, and from being recalled. */
+    writtenHeat: number;
+    recallHeat: number;
+    tier: Tier;
+    halfLifeDays: number;
+    /** Whether it's in the boot digest: what the agent wakes up holding. */
+    inDigest: boolean;
+}
+/** Live memories (not episodes) hottest first, each marked with whether the digest carries it. */
+export declare function heatList(contextDir: string, opts?: {
+    limit?: number;
+    category?: string;
+    nowMs?: number;
+}): {
+    rows: MemoryView[];
+    total: number;
+    inDigest: number;
+};
+export declare function memoryByRef(contextDir: string, ref: string, nowMs?: number): MemoryView | null;
+/** User memories tagged to a person, newest first. */
+export declare function memoriesAbout(contextDir: string, slug: string, opts?: {
+    since?: string | null;
+    limit?: number;
+    nowMs?: number;
+}): MemoryView[];
+export interface TapeEntry {
+    ref: string;
+    title: string;
+    created: string;
+    where: string;
+}
+/** Episodes in the last `hours`, newest first, with where each body was. */
+export declare function tapeRows(contextDir: string, hours: number, nowMs?: number): TapeEntry[];