honestweek 0.2.0 → 0.3.0

package/lib/view/data.mjs

@@ -22,20 +22,23 @@ import { randomBytes } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 
 import { buildWorkHistory } from '../replay/index.mjs';
+import { logIdHash } from '../replay/saved-sessions.mjs';
 import { normalizeGoalRecord } from '../replay/goals.mjs';
 import { letterHash } from '../replay/ids.mjs';
 import { createRedactor, createSecretsOnlyRedactor } from '../redact.mjs';
 import { createLeakCounter } from './leaks.mjs';
 import { buildTimeline } from '../replay/timeline.mjs';
-import { localDay } from '../replay/views.mjs';
+import { describe, localDay } from '../replay/views.mjs';
 import { privateWordCount, privateWordsNote } from '../private-words.mjs';
 import { eventRow, exportThread, frameAt, frameMoments, sessionGroup, timeNoteOf, whoOf } from './replay-export.mjs';
-import { buildWordIndex, createWordSearch, cutRedacted } from './word-index.mjs';
+import { buildWordIndex, createWordSearch, cutRedacted } from '../replay/word-index.mjs';
+import { matchWords, similarPrompts, WORD_RULES, wordsOf } from '../replay/words.mjs';
 import { createProblemsRoute } from './problems-route.mjs';
 import { earlierWindow, runProblems, trendCounts } from '../problems/index.mjs';
 import { INSIGHTS_TEXT } from './insights.mjs';
 import { sessionFacts, windowTotals } from './facts.mjs';
 import { sessionText } from './codex-judge.mjs';
+import { suggestWords } from './suggest-words.mjs';
 
 /** The most moments a goal page samples per member session. */
 const GOAL_FRAMES = 600;
@@ -49,11 +52,9 @@ export const SESSIONS_PAGE = 20;
 /** The day a session with no recorded time is listed under, after every dated day. */
 export const NO_DAY = 'none';
 
-/** The rules behind results the page computes itself, beside the engine's own. */
-export const VIEW_RULES = Object.freeze({
-  'view.shared-words': 'A prompt shares some of the words you typed. The score counts how many of your words appear in it as whole words; sharing words doesn\'t mean it was about the same thing.',
-  'view.similar-prompt': 'Two prompts share a large part of their words (the shared words divided by all the words either uses). Similar wording doesn\'t mean similar work.',
-});
+/** The rules behind results the page computes itself, beside the engine's own: the phrase
+ *  search's (lib/replay/words.mjs). */
+export const VIEW_RULES = WORD_RULES;
 
 /** The five evidence words every page uses, in plain words. */
 export const EVIDENCE_KEY = Object.freeze({
@@ -99,8 +100,6 @@ export function demoNotice(run) {
   });
 }
 
-const STOP = new Set(['a', 'an', 'and', 'are', 'as', 'at', 'be', 'but', 'by', 'can', 'do', 'for', 'from', 'if', 'in', 'into', 'is', 'it', 'its', 'just', 'me', 'my', 'no', 'not', 'of', 'on', 'or', 'so', 'that', 'the', 'then', 'this', 'to', 'up', 'we', 'with', 'you', 'your', 'i', 'redacted']);
-const MARKERS = /\[redacted:[a-z]+\]/g;
 
 /** A goal's key: a letter hash of its raw id, so it never shows the id and the redactor
  *  never alters it. */
@@ -108,10 +107,8 @@ export function goalKey(rawId) {
   return `g${letterHash(`goal\u0000${String(rawId)}`, 15)}`;
 }
 
-/** Lowercased words of a text, its redaction markers taken out first. */
-export function wordsOf(text) {
-  return (String(text ?? '').replace(MARKERS, ' ').toLowerCase().match(/[\p{L}\p{N}][\p{L}\p{N}_'-]*/gu) ?? []).filter((w) => w.length >= 2 && !STOP.has(w));
-}
+/** Lowercased words of a text (the engine's phrase search, lib/replay/words.mjs). */
+export { wordsOf };
 
 /** A small least-recently-used map: get() refreshes an entry, set() drops the oldest
  *  once it holds more than `size`. */
@@ -181,6 +178,38 @@ function firstWords(text, n = 8) {
 }
 
 const daysBetween = (from, to) => Math.round((Date.parse(`${to}T00:00:00Z`) - Date.parse(`${from}T00:00:00Z`)) / 86400000) + 1;
+
+/** The shortest start of an id that `matchSession` reads as that id. */
+export const SESSION_PREFIX_MIN = 8;
+
+/**
+ * matchSession(h, text) -> { key, group, checked } | { matches: [key...] } | { none: true }
+ * A session of history `h` by its key, by the id in its own log (a Claude Code session's id, a
+ * Codex thread id, which the engine keeps in memory only), or by the start of either,
+ * SESSION_PREFIX_MIN characters or more. A start several sessions share returns them all.
+ * `checked` is the Problems checks' own rule: a session in a configured repository.
+ */
+export function matchSession(h, text) {
+  const want = String(text ?? '').trim().toLowerCase();
+  if (!want || want.length > 200) return { none: true };
+  const ownIds = [...(h.claudeIds ?? new Map()), ...(h.codexIds ?? new Map())];
+  const byKey = new Map(h.sessions.map((s) => [s.key, s]));
+  const found = (key) => {
+    const s = byKey.get(key);
+    return s ? { key, group: sessionGroup(s), checked: sessionGroup(s) === 'configured' } : null;
+  };
+  // A session that came back from saved results keeps its log's id only as a hash: a full id finds it.
+  const savedId = h.savedLogIds?.size ? [...h.savedLogIds].find(([, x]) => x === logIdHash(want))?.[0] : undefined;
+  const exact = found(want) ?? found(ownIds.find(([, id]) => id === want)?.[0]) ?? found(savedId);
+  if (exact) return exact;
+  if (want.length < SESSION_PREFIX_MIN) return { none: true };
+  const keys = new Set([...byKey.keys()].filter((k) => k.startsWith(want)));
+  for (const [k, id] of ownIds) if (id.startsWith(want) && byKey.has(k)) keys.add(k);
+  const list = [...keys].sort();
+  if (list.length === 1) return found(list[0]);
+  return list.length ? { matches: list } : { none: true };
+}
+
 const ID_RE = /^[A-Za-z0-9._-]{1,200}$/;
 const DAY_RE = /^\d{4}-\d{2}-\d{2}$/;
 const OFFSET_RE = /^\d{1,6}$/;
@@ -263,7 +292,7 @@ function goalSplit(members) {
 // The private-word count and note live in lib/private-words.mjs, shared with init.
 export { privateWordCount, privateWordsNote };
 
-export function createViewData({ config, roots, from, to, timezone, goalRecord = null, demo = false, selfTest = false, command: ranAs = 'honestweek', buildHistory = buildWorkHistory, cacheSize = REPLAY_CACHE_SIZE, now = () => Date.now(), windowNote = null, insights = null, codexJudge = null, partial = null, onProgress = null, earlierCheck = null, privateCheck = null, earlierProgressive = false, queries = null }) {
+export function createViewData({ config, roots, from, to, timezone, goalRecord = null, demo = false, selfTest = false, command: ranAs = 'honestweek', buildHistory = buildWorkHistory, cacheSize = REPLAY_CACHE_SIZE, now = () => Date.now(), windowNote = null, insights = null, codexJudge = null, settingsOpen = true, partial = null, onProgress = null, earlierCheck = null, privateCheck = null, earlierProgressive = false, queries = null, onChecked = null, savedLoad = null, savedCounts = null }) {
   const wordCount = privateWordCount(config);
   const fullRedactor = createRedactor(config);
   // How the person ran honestweek, for the commands a page names. It goes through the
@@ -292,7 +321,8 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
   const builds = { redacted: slot(), private: slot() };
   const words = { state: 'waiting', ms: null, error: null, search: null, sessions: 0 };
 
-  // Set when Settings replaces this data: a build still reading stops before any git read.
+  // Set when Settings replaces this data or the page stops: a build still reading, this
+  // window's or the week before's, stops at its next check and runs no more git.
   const signal = { aborted: false };
   const reason = (err) => cutRedacted(fullRedactor.redact(String(err?.message ?? err ?? 'unknown error').split('\n')[0]), 200);
 
@@ -308,6 +338,17 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
     // redacted text rather than skeletons; an engine without that option ignores it.
     // The redacted build also records token counts and keeps raw text in memory for the
     // problem checks, which run on it alone; an engine without those options ignores them.
+    // Saved sessions whose logs are gone (lib/saved/history.mjs) join both builds, redacted as
+    // saved: private text is never saved, so the private build shows them redacted too. The
+    // redacted build is the one saved from, so it keeps what the saver exports.
+    const savedNow = savedSessions();
+    if (savedNow) {
+      options.saved = savedNow.sessions;
+      // Sessions whose logs haven't changed since they were saved come back unread, in the
+      // redacted build only: the private build reads their logs for the text the saved copy hid.
+      if (mode === 'redacted' && savedNow.reuse?.size) options.reuse = savedNow.reuse;
+    }
+    if (mode === 'redacted' && typeof onChecked === 'function') options.saving = true;
     if (mode === 'private') options.privateText = true;
     else Object.assign(options, { hiddenSessions: 'redacted', usage: true, keepRaw: true, ...(typeof onProgress === 'function' ? { onProgress } : {}) });
     // A second copy of a large window may not fit beside the first: it isn't built then, and the
@@ -329,6 +370,7 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
           b.state = 'ready';
           b.ms = now() - b.startedAt;
           if (mode === 'redacted') startWords(h);
+          if (mode === 'redacted' && !partial && typeof onChecked === 'function') checkedReady(b);
         },
         (err) => {
           b.state = 'failed';
@@ -339,6 +381,35 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
     return b.promise;
   }
 
+  // With "saveResults" on (lib/saved/), the whole window's check results go to `onChecked` once
+  // its redacted build is ready: the same run of the checks every Problems answer reads, so they
+  // run once. A first day shown while the rest loads (`partial`) is never saved. A failure to
+  // save is the saver's to report; the page goes on.
+  function checkedReady(b) {
+    setTimeout(() => {
+      if (signal.aborted || builds.redacted !== b) return;
+      try {
+        const c = problemsRoute.checked(b.h, b.startedAt);
+        if (c) onChecked({ h: b.h, builtT: b.startedAt, result: c.result, keys: c.keys, describeStep: (id) => (b.eventsById.has(id) ? describe(b.eventsById.get(id)) : null) });
+      } catch {
+        /* the saver records its own failure */
+      }
+    }, 0);
+  }
+
+  // Read once, for both builds and the checks.
+  let savedRead;
+  function savedSessions() {
+    if (savedRead === undefined) {
+      try {
+        savedRead = typeof savedLoad === 'function' ? savedLoad({ from, to, timezone }) ?? null : null;
+      } catch {
+        savedRead = null;
+      }
+    }
+    return savedRead;
+  }
+
   function startWords(h) {
     words.state = 'building';
     const t0 = now();
@@ -423,7 +494,7 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
       // config lists any private words (the demo always has its made-up one).
       command,
       // One short line on every page; the rest of the note sits behind its "?".
-      privateWords: { count: wordCount, note: !demo && wordCount === 0 ? PRIVATE_WORDS_SHORT : null, more: !demo && wordCount === 0 ? privateWordsNote(command, { restart: false }) : null },
+      privateWords: { count: wordCount, note: !demo && wordCount === 0 ? PRIVATE_WORDS_SHORT : null, more: !demo && wordCount === 0 ? privateWordsNote(command, { restart: false, settings: settingsOpen }) : null },
       selfTest,
       evidenceKey: EVIDENCE_KEY,
     };
@@ -572,11 +643,14 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
     return launch ? { ...sb, launch } : sb;
   }
 
+  /** A session that came back as saved (lib/saved/history.mjs): when, by which version, and
+   *  whether its log is gone. Nothing for any other session, so its answer is what it was. */
+  const savedOf = (s) => (s?.saved ? { saved: { at: s.saved.at ?? null, by: s.saved.by ?? null, log: s.saved.log ?? null } } : {});
   const sessionRow = (ctx, key) => {
     const s = ctx.sessionByKey.get(key);
     if (!s) return { session: key, thread: null, tool: null, repo: null, group: null, title: null, firstAt: null, lastAt: null, startedBy: null };
     const label = labelOf(ctx, s.key);
-    return { session: s.key, thread: s.thread, tool: s.tool, repo: s.repo, group: sessionGroup(s), title: s.title, ...(label ? { label } : {}), firstAt: s.firstAt, lastAt: s.lastAt, startedBy: startedWith(ctx, s.key) };
+    return { session: s.key, thread: s.thread, tool: s.tool, repo: s.repo, group: sessionGroup(s), title: s.title, ...(label ? { label } : {}), firstAt: s.firstAt, lastAt: s.lastAt, startedBy: startedWith(ctx, s.key), ...savedOf(s) };
   };
 
   /** The goals a session is a member of, each with that session's place in the goal. */
@@ -776,73 +850,36 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
     return { event: e.id, ...sessionRow(ctx, e.session), t: e.t, at: e.at ?? null, text: cutRedacted(String(e.facts?.text ?? ''), 240), who: whoOf(e, new Map(ctx.h.agents.map((a) => [a.key, a]))), goals: goalsOfSession(ctx, e.session), ...extra };
   }
 
+  // Phrase search is the engine's (lib/replay/words.mjs): display-only and outside sessions never
+  // join a lookup, whichever build answers. These shape its matches into the page's rows.
   function wordSearch(ctx, params) {
-    const h = ctx.h;
-    // Display-only and outside sessions never join a lookup, whichever build answers.
-    const prompts = readableEvents(ctx).filter((e) => e.kind === 'prompt' && typeof e.facts?.text === 'string' && e.facts.text);
     const similarTo = params.get('similar');
     if (similarTo) {
       if (!ID_RE.test(similarTo)) return json(400, { error: 'That prompt id is malformed.' });
-      const base = prompts.find((e) => e.id === similarTo);
-      if (!base) return json(404, { error: 'No prompt with that id in this window.' });
-      const mine = new Set(wordsOf(base.facts.text));
-      const similar = prompts
-        .filter((e) => e.id !== base.id)
-        .map((e) => {
-          const theirs = new Set(wordsOf(e.facts.text));
-          let shared = 0;
-          for (const w of theirs) if (mine.has(w)) shared += 1;
-          const union = mine.size + theirs.size - shared;
-          return { e, score: union ? shared / union : 0 };
-        })
-        .filter((x) => x.score >= 0.2)
-        .sort((a, b) => b.score - a.score || b.e.t - a.e.t)
-        .slice(0, 10)
-        .map(({ e, score }) => promptRow(ctx, e, { evidence: 'inferred', rule: 'view.similar-prompt', score: { value: Math.round(score * 100) / 100, evidence: 'inferred', rule: 'view.similar-prompt' } }));
-      return { similarTo: base.id, similar, goals: [], sessions: [], branches: [], prompts: [], empty: similar.length ? null : 'No prompt in this window shares enough words with that one.', rules: VIEW_RULES, evidenceKey: EVIDENCE_KEY };
+      const found = similarPrompts(ctx.h, similarTo);
+      if (!found) return json(404, { error: 'No prompt with that id in this window.' });
+      const similar = found.map(({ event: e, score }) => promptRow(ctx, e, { evidence: 'inferred', rule: 'view.similar-prompt', score: { value: Math.round(score * 100) / 100, evidence: 'inferred', rule: 'view.similar-prompt' } }));
+      return { similarTo, similar, goals: [], sessions: [], branches: [], prompts: [], empty: similar.length ? null : 'No prompt in this window shares enough words with that one.', rules: VIEW_RULES, evidenceKey: EVIDENCE_KEY };
     }
     const query = readQuery(params, { goals: [], sessions: [], branches: [], prompts: [], similar: [] });
     if (query.answer) return query.answer;
-    return withQuery(query, wordsFor(ctx, query.text, prompts));
+    return withQuery(query, wordsFor(ctx, query.text));
   }
 
-  function wordsFor(ctx, q, prompts) {
+  function wordsFor(ctx, q) {
     const h = ctx.h;
-    const want = [...new Set(wordsOf(q))];
-    const low = q.toLowerCase();
-    const has = (text) => want.length > 0 && want.every((w) => String(text ?? '').toLowerCase().includes(w));
+    const m = matchWords(h, q);
     const goals = record
-      ? h.goals.flatMap((g, i) => {
-          const inTitle = has(g.title);
-          const inId = has(g.id);
-          return inTitle || inId ? [{ key: keys[i], title: g.title, state: g.state, matchedIn: inTitle ? 'title' : 'id', evidence: 'recorded', members: memberCount(g.members) }] : [];
+      ? m.goals.map(({ index, matchedIn }) => {
+          const g = h.goals[index];
+          return { key: keys[index], title: g.title, state: g.state, matchedIn, evidence: 'recorded', members: memberCount(g.members) };
         })
       : [];
-    const sessions = h.sessions.filter((s) => s.private === false && s.title && has(s.title)).map((s) => ({ ...sessionRow(ctx, s.key), evidence: 'recorded', goals: goalsOfSession(ctx, s.key) }));
-    const branchMap = new Map();
-    for (const e of readableEvents(ctx)) {
-      const f = e.facts ?? {};
-      for (const b of [f.git?.push?.branch, f.git?.branch?.ref, e.kind === 'mode' ? f.branch : null]) {
-        if (typeof b !== 'string' || !b || !b.toLowerCase().includes(low)) continue;
-        if (!branchMap.has(b)) branchMap.set(b, new Map());
-        if (!branchMap.get(b).has(e.session)) branchMap.get(b).set(e.session, e.id);
-      }
-    }
-    const branches = [...branchMap].map(([branch, bySession]) => ({ branch, evidence: 'recorded', sessions: [...bySession].map(([session, event]) => ({ ...sessionRow(ctx, session), event, evidence: 'recorded' })) }));
-    const scored = prompts
-      .map((e) => {
-        const theirs = new Set(wordsOf(e.facts.text));
-        const shared = want.filter((w) => theirs.has(w)).length;
-        return { e, shared };
-      })
-      .filter((x) => x.shared > 0)
-      .sort((a, b) => b.shared - a.shared || b.e.t - a.e.t)
-      .slice(0, 20)
-      .map(({ e, shared }) => {
-        // The words are in the prompt's text, so the row is recorded; ranking it by how many
-        // of them it shares is a named rule's reading, so the score is inferred.
-        return promptRow(ctx, e, { evidence: 'recorded', rule: 'view.shared-words', matched: shared === want.length ? 'all your words' : 'some of your words', score: { value: shared, of: want.length, evidence: 'inferred', rule: 'view.shared-words' } });
-      });
+    const sessions = m.sessions.map((key) => ({ ...sessionRow(ctx, key), evidence: 'recorded', goals: goalsOfSession(ctx, key) }));
+    const branches = m.branches.map(({ branch, sessions: bySession }) => ({ branch, evidence: 'recorded', sessions: bySession.map(({ session, event }) => ({ ...sessionRow(ctx, session), event, evidence: 'recorded' })) }));
+    // The words are in the prompt's text, so the row is recorded; ranking it by how many of them
+    // it shares is a named rule's reading, so the score is inferred.
+    const scored = m.prompts.map(({ event: e, shared }) => promptRow(ctx, e, { evidence: 'recorded', rule: 'view.shared-words', matched: shared === m.want.length ? 'all your words' : 'some of your words', score: { value: shared, of: m.want.length, evidence: 'inferred', rule: 'view.shared-words' } }));
     const nothing = !goals.length && !sessions.length && !branches.length && !scored.length;
     return { goals, sessions, branches, prompts: scored, similar: [], empty: nothing ? emptyText() : null, rules: VIEW_RULES, evidenceKey: EVIDENCE_KEY };
   }
@@ -928,6 +965,16 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
       if (launch) data = { ...data, launch };
       ctx.b.replays.set(cacheKey, data);
     }
+    // `at` (milliseconds): the thread's state at exactly that moment, read from its timeline
+    // rather than the sampled frames, which change only at a step's start. `replay --at` asks
+    // for it; the page doesn't, so its answer stays as it was.
+    const at = params.get('at');
+    if (at !== null) {
+      const t = Number(at);
+      if (at.trim() === '' || !Number.isFinite(t)) return json(400, { error: 'That moment is malformed.' });
+      const tl = h.threadTimeline(threadId);
+      return { ...data, atFrame: tl ? frameAt(tl, t) : null };
+    }
     return data;
   }
 
@@ -959,6 +1006,7 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
       git: !!r.ref?.sha,
       verified: r.verified,
       note: r.note,
+      ...(r.saved === true ? { saved: true } : {}),
       record: r.record == null ? null : joinLinesWhereNeeded(r.record, ctx.redact),
     }));
     const result = reads.find((x) => x.part === 'result');
@@ -1045,7 +1093,8 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
   // ---- problems: the checks run once on the redacted build; each answer is drawn for its own --
   // The long-session check runs only with a limit set in Settings (config.longSessionTokens).
   const longSession = Number.isInteger(config?.longSessionTokens) ? config.longSessionTokens : null;
-  const problemsRoute = createProblemsRoute({ now, longSessionTokens: longSession });
+  // A saved session's findings are the ones saved with it (runProblems' `saved`).
+  const problemsRoute = createProblemsRoute({ now, longSessionTokens: longSession, run: (h, o) => runProblems(h, { ...o, saved: savedSessions()?.findings ?? null, savedStatus: savedSessions()?.statuses ?? null }) });
   /** The sessions a goal joins, by the redacted build's membership (the same in both builds). */
   function membersOfGoal(key) {
     const i = indexOfKey.get(String(key ?? ''));
@@ -1082,6 +1131,14 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
       return { first: null, whole: Promise.resolve(value), done };
     };
     if (!w) return settled({ window: null, error: 'no window' });
+    // With every day of it saved, its counts come from the saved check results, and nothing is read.
+    let fromSaved = null;
+    try {
+      fromSaved = typeof savedCounts === 'function' ? savedCounts({ from: w.from, to: w.to, timezone }) : null;
+    } catch {
+      fromSaved = null;
+    }
+    if (fromSaved) return settled({ window: w, ...fromSaved, saved: true, ms: 0 });
     // Past the log limit, or more than memory holds beside this window: not read, or only its
     // newest days, and the page says which in a few words.
     const check = typeof earlierCheck === 'function' ? earlierCheck(w) : null;
@@ -1089,11 +1146,18 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
     const wholeFrom = check?.from ?? w.from;
     const count = (a, b) => {
       const t0 = now();
+      // The days before count their saved sessions whose logs are gone too, as this window does.
+      let back = null;
+      try {
+        back = typeof savedLoad === 'function' ? savedLoad({ from: a, to: b, timezone }) ?? null : null;
+      } catch {
+        back = null;
+      }
       return Promise.resolve()
-        .then(() => buildHistory({ config, roots, from: a, to: b, timezone, scope: 'all', updates: true, hiddenSessions: 'redacted', usage: true, keepRaw: true }))
+        .then(() => buildHistory({ config, roots, from: a, to: b, timezone, scope: 'all', updates: true, hiddenSessions: 'redacted', usage: true, keepRaw: true, signal, ...(back ? { saved: back.sessions } : {}) }))
         .then(
           // Only the counts are kept: the history and the checks' result go with this function.
-          (h) => ({ window: w, ...trendCounts(runProblems(h, { builtT: now(), longSessionTokens: longSession })), ms: now() - t0 }),
+          (h) => ({ window: w, ...trendCounts(runProblems(h, { builtT: now(), longSessionTokens: longSession, ...(back ? { saved: back.findings } : {}) })), ms: now() - t0 }),
           (err) => ({ window: w, error: reason(err), ms: now() - t0 }),
         );
     };
@@ -1252,7 +1316,20 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
     return { sessions, totals: Object.fromEntries(Object.entries(totals).map(([k, t]) => [k, { sessions: t.sessions, facts: shown(t.facts) }])) };
   }
 
-  const ROUTES = { '/api/home': home, '/api/sessions': sessionsList, '/api/problems': problems, '/api/insights': insightsRoute, '/api/facts': factsRoute, '/api/lookup': lookup, '/api/words': wordSearch, '/api/goal': goal, '/api/replay': replay, '/api/record': recordRoute, '/api/search': search, ...(selfTest ? { '/api/selftest': selftestInfo } : {}) };
+  /** Settings' "Suggest words": name-shaped words in my configured sessions' prompts and titles.
+   *  Always from the redacted build, whichever version the page shows, so a word already hidden
+   *  never comes back as a suggestion. */
+  function suggestedWords() {
+    const { h, redact } = context('redacted');
+    // A prompt's shown text is an excerpt, which can miss a later name or cut a code block
+    // open; the whole prompt the engine keeps in memory is scanned instead, redacted first.
+    const promptText = (e) => (typeof e._raw?.text === 'string' ? redact(e._raw.text) : e.facts?.text);
+    const listed = ['names', 'terms', 'codenames'].flatMap((k) => (Array.isArray(config?.redaction?.[k]) ? config.redaction[k] : []));
+    const labels = (Array.isArray(config?.repos) ? config.repos : []).flatMap((r) => (typeof r?.label === 'string' ? r.label.split(/[^\p{L}\p{N}]+/u) : []));
+    return { words: suggestWords({ sessions: h.sessions, events: h.events, include: (s) => sessionGroup(s) === 'configured', exclude: [...listed, ...labels], promptText }) };
+  }
+
+  const ROUTES = { '/api/suggest-words': suggestedWords, '/api/home': home, '/api/sessions': sessionsList, '/api/problems': problems, '/api/insights': insightsRoute, '/api/facts': factsRoute, '/api/lookup': lookup, '/api/words': wordSearch, '/api/goal': goal, '/api/replay': replay, '/api/record': recordRoute, '/api/search': search, ...(selfTest ? { '/api/selftest': selftestInfo } : {}) };
 
   /** Answer one data request. `params` is the request's URLSearchParams. */
   async function route(path, params) {
@@ -1306,7 +1383,14 @@ export function createViewData({ config, roots, from, to, timezone, goalRecord =
     signal.aborted = true;
   }
 
-  return { start, stop, status, route, leakCheck, codexWork, routes: ['/api/status', ...Object.keys(ROUTES)] };
+  /** Settles once "search everywhere" has read the logs, or failed to (after start()). */
+  const searchReady = () => words.promise ?? Promise.resolve();
+
+  /** matchSession over the redacted build, for the commands in this process only: no route
+   *  answers it, so a log's own id never reaches the page. Null until that build is ready. */
+  const sessionMatch = (text) => (builds.redacted.state === 'ready' ? matchSession(builds.redacted.h, text) : null);
+
+  return { start, stop, status, route, leakCheck, codexWork, searchReady, sessionMatch, routes: ['/api/status', ...Object.keys(ROUTES)] };
 }
 
 /** The text a tool call's result record holds, from either harness's record shape. */

package/lib/view/own-week.mjs

@@ -0,0 +1,119 @@
+// lib/view/own-week.mjs: the person's own week, as `honestweek view` reads it and the find,
+// replay, problems and goals commands (lib/ask.mjs) read it too: the config the lookup finds,
+// the window the options or the config's "history" name, the log folders, and the goal list.
+// Read-only: it opens the config and the goal list, and sizes the logs by their files alone.
+
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, resolve } from 'node:path';
+
+import { HISTORY_LIMIT_MB, loadConfig } from '../config.mjs';
+import { findConfig } from '../config-lookup.mjs';
+import { currentCommand } from '../invocation.mjs';
+import { normalizeGoalRecord } from '../replay/goals.mjs';
+import { defaultRoots } from '../replay/sources.mjs';
+import { localDateInTimezone } from '../resolve-week.mjs';
+import { withSavedDays } from '../saved/history.mjs';
+import { savedDirOf, savedOptions } from '../saved/store.mjs';
+import { logFiles, planWindow } from './window.mjs';
+
+const DEFAULT_DAYS = 7;
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+
+/** A plain message for a setting that can't be read: `view` prints it and stops. */
+export class SetupError extends Error {}
+export const setup = (message) => new SetupError(message);
+
+export const validDate = (s) => DATE_RE.test(s) && !Number.isNaN(Date.parse(`${s}T00:00:00Z`)) && new Date(`${s}T00:00:00Z`).toISOString().slice(0, 10) === s;
+export const spanDays = (a, b) => Math.round((Date.parse(`${b}T00:00:00Z`) - Date.parse(`${a}T00:00:00Z`)) / 86400000) + 1;
+export const shiftDay = (day, n) => new Date(Date.parse(`${day}T00:00:00Z`) + n * 86400000).toISOString().slice(0, 10);
+
+export function validTimezone(tz) {
+  try {
+    new Intl.DateTimeFormat('en-US', { timeZone: tz });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** The window to read: --from/--to, or the last --days days (default 7) ending today. */
+export function resolveViewWindow(values, timezone, now = Date.now()) {
+  const hasRange = '--from' in values || '--to' in values;
+  if (hasRange && '--days' in values) throw setup('view: use --days, or --from with --to, not both.');
+  if (hasRange) {
+    const from = values['--from'];
+    const to = values['--to'];
+    if (from === undefined || to === undefined) throw setup('view: --from and --to go together. Give both, or use --days.');
+    for (const [name, v] of [['--from', from], ['--to', to]]) if (!validDate(v)) throw setup(`view: ${name} must be a date written YYYY-MM-DD (got ${JSON.stringify(v)}).`);
+    if (from > to) throw setup(`view: --from (${from}) is after --to (${to}).`);
+    return { from, to };
+  }
+  let days = DEFAULT_DAYS;
+  if ('--days' in values) {
+    const v = values['--days'];
+    if (!/^\d{1,4}$/.test(v) || Number(v) < 1 || Number(v) > 3660) throw setup(`view: --days must be a whole number from 1 to 3660 (got ${JSON.stringify(v)}).`);
+    days = Number(v);
+  }
+  const today = localDateInTimezone(new Date(now), timezone).toISOString().slice(0, 10);
+  return { from: shiftDay(today, -(days - 1)), to: today };
+}
+
+/**
+ * readGoalList(path) -> the parsed goal list. Throws a setup error with a plain message
+ * when the file is missing, can't be read as JSON, is the goals page's registry, or doesn't fit.
+ */
+export function readGoalList(path) {
+  if (!existsSync(path)) throw setup(`view: no goal list at ${path}. Fix the path, or leave the goal list out; search and replay work without one.`);
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    // Never the parser's message: it quotes the file's first characters, and this check takes
+    // any path. A folder or an unreadable file reads the same as a file that isn't JSON.
+    throw setup(`view: ${path} isn't a goal list (not valid JSON).`);
+  }
+  const looksLikeRegistry = parsed && typeof parsed === 'object' && !Array.isArray(parsed.goals) && (parsed.objectives !== undefined || parsed.projectToObjective !== undefined);
+  if (looksLikeRegistry) {
+    throw setup(`view: ${path} looks like the goals page's list (its "objectives"), which honestweek build reads. view reads a different file, a goal list: { "goals": [{ "id": "g-1", "title": "Ship the parser" }], "events": [] }. The README's goal list section shows the format.`);
+  }
+  try {
+    normalizeGoalRecord(parsed);
+  } catch (err) {
+    throw setup(`view: ${path} isn't a goal list: ${String(err?.message ?? err).replace(/^replay: /, '')}`);
+  }
+  return parsed;
+}
+
+/** The config's limit on log data a saved choice loads, in MB. */
+export const limitOf = (config) => config?.historyLimitMB ?? HISTORY_LIMIT_MB.default;
+
+export const absolute = (cwd, p) => (isAbsolute(p) ? p : resolve(cwd, p));
+
+/** The person's own week: the config, the window and the goal list the options and the config
+ *  name. Throws a setup error with a plain message when one of them can't be read. The find,
+ *  replay, problems and goals commands (lib/ask.mjs) read the same week. */
+export function ownWeek({ values, cwd, env, now }) {
+  const configPath = findConfig({ cwd, flag: values['--config'] }).path;
+  if (!existsSync(configPath)) throw setup(`view: no config at ${configPath}. Run ${currentCommand()} view in a folder with no config to set one up in your browser (or ${currentCommand()} init in a terminal), or ${currentCommand()} view --demo to look around a made-up week first.`);
+  let config;
+  try {
+    config = loadConfig(configPath);
+  } catch (err) {
+    throw setup(`view: ${err.message}`);
+  }
+  const timezone = values['--timezone'] ?? config.week?.timezone;
+  if (!validTimezone(timezone)) throw setup(`view: ${JSON.stringify(timezone)} isn't a timezone this machine knows. Use an IANA name such as Europe/Paris or UTC.`);
+  const roots = defaultRoots(env);
+  // The flags win for one run. With none, a saved choice is sized to fit (the last week, or up to
+  // 7 days, always whole); with no saved choice either, it's the last 7 days, as it always was.
+  // Either way a window of more than one day loads its newest day first.
+  const flagged = ['--days', '--from', '--to'].some((f) => f in values);
+  // With each day's history saved, a saved day with no log left counts too: "all history" reaches
+  // back to the oldest one, and the limit counts what it brings back.
+  const files = savedOptions(config)?.history ? withSavedDays(logFiles(roots, timezone), savedDirOf(dirname(configPath))) : undefined;
+  const plan = !flagged && config.history ? planWindow(config.history, { roots, timezone, now: now(), maxBytes: limitOf(config) * 1024 * 1024, ...(files ? { files } : {}) }) : null;
+  const { from, to } = plan ?? resolveViewWindow(values, timezone, now());
+  const goalsPath = values['--goals'] ? absolute(cwd, values['--goals']) : config.goalsFile ?? null;
+  const goalRecord = goalsPath ? readGoalList(goalsPath) : null;
+  return { config, configPath, roots, from, to, timezone, goalRecord, windowNote: plan?.note ?? null, ...(files ? { files } : {}) };
+}

package/lib/view/page-link.mjs

@@ -0,0 +1,84 @@
+// lib/view/page-link.mjs: which page, query and step a one-time address from `view` may open
+// (issue 198), so an agent or a person can hand someone a link straight to a session or a step.
+//
+// Only view's own pages are accepted, never a path: nothing here joins a path from the request,
+// and the server serves a fixed list of files anyway. The query is parsed and written back
+// encoded, with plain keys only. The part after `#` is the replay page's thread and step, so it
+// takes ids only: letters, digits and `_ . ~ : -`, which also keeps out an `&c=` that would
+// pose as the one-time code key.js reads from that same part of the address. Search is the one
+// page with a part of its own: the id of a search this run keeps in memory (#q=<id>~l or ~w,
+// as search.js writes it), and no query, since its address never holds what was typed.
+
+/** The pages a link may open. Setup has its own flow, and the self-test its own address. */
+export const LINK_PAGES = Object.freeze(['problems.html', 'replay.html', 'search.html', 'goal.html', 'settings.html']);
+
+const KEY = /^[A-Za-z]{1,24}$/;
+const FRAGMENT = /^[A-Za-z0-9_.~:-]{1,300}$/;
+/** Search's own part after `#`: a search id this run gave out (QUERY_ID_RE in data.mjs). */
+const SEARCH_FRAGMENT = /^q=q[a-p]{16}(?:~[lw])?$/;
+
+/** The page's own ids, as `ID` in lib/view/assets/common.js has them (a test keeps the two the same). */
+export const PAGE_IDS = Object.freeze({
+  thread: /^th-[a-p]{4,64}$/,
+  session: /^[a-z]{2,4}-[a-p]{4,64}$/,
+  event: /^[a-z]{2,4}-[a-p]{4,64}(?:[.:][A-Za-z0-9_-]{1,80}){0,6}$/,
+  goal: /^(?:[a-z]{1,4}-)?[a-p]{4,64}$/,
+});
+const isId = (kind, v) => typeof v === 'string' && v.length <= 300 && PAGE_IDS[kind].test(v);
+
+/**
+ * replayPage({ session, thread, event }) -> 'replay.html?session=<id>#<thread>~<step>' | null
+ * A session's replay, or one step of it, built the way the Problems page builds its own links:
+ * ids only, so null for anything that isn't one of the page's ids.
+ */
+export function replayPage({ session, thread = null, event = null } = {}) {
+  if (!isId('session', session)) return null;
+  const t = isId('thread', thread) ? thread : '';
+  const e = isId('event', event) ? `~${event}` : '';
+  return `replay.html?session=${encodeURIComponent(session)}${t || e ? `#${t}${e}` : ''}`;
+}
+
+/**
+ * zoomPage(finding) -> 'replay.html?session=<id>#<thread>~zoom~<finding key>' | null
+ * The replay zoomed to the steps a finding's check recorded, in its own thread's lane when it has
+ * one, else its first: the same link the Problems page builds (zoomHref in assets/problems.js).
+ */
+export function zoomPage(f) {
+  const lanes = f?.zoom?.lanes;
+  if (!/^pf-[a-p]{12}$/.test(f?.key ?? '') || !Array.isArray(lanes) || !lanes.length) return null;
+  const lane = lanes.find((l) => l.thread === f.thread) ?? lanes[0];
+  if (!isId('session', lane?.session) || !isId('thread', lane?.thread)) return null;
+  return `replay.html?session=${encodeURIComponent(lane.session)}#${lane.thread}~zoom~${f.key}`;
+}
+
+/** A goal's page, 'goal.html#<key>', or null. */
+export const goalPage = (key) => (isId('goal', key) ? `goal.html#${key}` : null);
+
+/** The Problems page narrowed to one session's findings, 'problems.html?session=<key>', or null. */
+export const problemsPage = (session) => (isId('session', session) ? `problems.html?session=${encodeURIComponent(session)}` : null);
+
+/**
+ * pageLink(text) -> { page } | { error }
+ * `page` is what follows the server's address: a page name, an optional `?query` and an
+ * optional `#fragment`, or '' for the Problems page. `error` is one plain line.
+ */
+export function pageLink(text) {
+  const raw = String(text ?? '').trim().replace(/^\/+/, '');
+  if (!raw) return { page: '' };
+  const hashAt = raw.indexOf('#');
+  const head = hashAt < 0 ? raw : raw.slice(0, hashAt);
+  const fragment = hashAt < 0 ? '' : raw.slice(hashAt + 1);
+  const queryAt = head.indexOf('?');
+  const name = queryAt < 0 ? head : head.slice(0, queryAt);
+  if (!LINK_PAGES.includes(name)) return { error: `${JSON.stringify(name.slice(0, 80))} isn't one of view's pages: ${LINK_PAGES.join(', ')}.` };
+  const params = new URLSearchParams(queryAt < 0 ? '' : head.slice(queryAt + 1));
+  for (const key of params.keys()) {
+    if (!KEY.test(key)) return { error: `${JSON.stringify(key.slice(0, 40))} isn't a key view's pages read.` };
+  }
+  const query = params.toString();
+  if (name === 'search.html') {
+    if (query) return { error: "Search takes no query: its address never holds what was typed. Copy a search's address from the page, #q= and all." };
+    if (fragment && !SEARCH_FRAGMENT.test(fragment)) return { error: "Search's part after # can only be a search's own id, as the page's address shows it (#q=<id>~w)." };
+  } else if (fragment && !FRAGMENT.test(fragment)) return { error: 'the part after # can hold only ids (letters, digits, and _ . ~ : -).' };
+  return { page: `${name}${query ? `?${query}` : ''}${fragment ? `#${fragment}` : ''}` };
+}