@timurtekb/tekjobs 0.45.0 → 0.47.0

package/app/dist/index.html

@@ -8,8 +8,8 @@
     <link rel="icon" href="/brand/tekjobs-avatar-192.png" type="image/png" sizes="192x192" />
     <link rel="apple-touch-icon" href="/brand/tekjobs-avatar-192.png" />
     <link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Bricolage+Grotesque:wght@500;600&family=Hanken+Grotesk:wght@400;500;600&family=Azeret+Mono:wght@400;500&display=swap" data-zengin="fonts" />
-    <script type="module" crossorigin src="/assets/index-BtNxvOxd.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-pTsHxrh7.css">
+    <script type="module" crossorigin src="/assets/index-DBhdgfnv.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-8e9hXz21.css">
   </head>
   <body>
     <div id="root"></div>

package/app/server/index.mjs

@@ -11,6 +11,7 @@ import * as mail from './mail-check.mjs';
 import * as people from './people.mjs';
 import * as linkedin from './linkedin-import.mjs';
 import { TOOLS } from './mcp.mjs';
+import { buildJournal, renderJournal, writeJournal } from '../../scraper/journal.mjs';
 
 const PORT = Number(process.env.PORT || 8787);
 const DIST = fileURLToPath(new URL('../dist', import.meta.url));
@@ -41,7 +42,7 @@ const routes = [
   ['GET', /^\/api\/jobs\/([^/]+)\/connections$/, (m) => linkedin.connectionsAt(store.getJob(decodeURIComponent(m[1])).company)],
   ['GET', /^\/api\/linkedin$/, () => linkedin.status()],
   ['POST', /^\/api\/linkedin\/preview$/, async (_, __, req) => { const b = await readBody(req); return linkedin.preview(b.source, { since: b.since || undefined, everyone: !!b.everyone }); }],
-  ['POST', /^\/api\/linkedin\/import$/, async (_, __, req) => { const b = await readBody(req); return linkedin.runImport(b.source, { since: b.since || undefined, everyone: !!b.everyone, writePeople: b.writePeople !== false, dry: !!b.dry }); }],
+  ['POST', /^\/api\/linkedin\/import$/, async (_, __, req) => { const b = await readBody(req); const r = linkedin.runImport(b.source, { since: b.since || undefined, everyone: !!b.everyone, writePeople: b.writePeople !== false, dry: !!b.dry }); if (b.applications || b.saved) r.jobs = linkedin.importJobs(b.source, { since: b.since || undefined, applications: !!b.applications, saved: !!b.saved, dry: !!b.dry }); return r; }],
   ['GET', /^\/api\/people$/, () => people.listPeople()],
   ['POST', /^\/api\/people$/, async (_, __, req) => { const b = await readBody(req); const p = people.createPerson(b); if (b.jobId) people.attachPerson(b.jobId, p.id, { role: b.role, context: b.context }); return people.getPerson(p.id); }],
   ['GET', /^\/api\/people\/([^/]+)$/, (m) => people.getPerson(decodeURIComponent(m[1]))],
@@ -72,6 +73,9 @@ const routes = [
   ['GET', /^\/api\/profile\/summary$/, () => store.profileSummary()],
   // The one-page confirmation after the interview: roles, where, pay, exclusions, proof points, what remains.
   ['GET', /^\/api\/learned$/, () => store.learned()],
+  // The day's journal: runs, found, decisions, mail, notes, read from the record. ?date=YYYY-MM-DD for another day.
+  ['GET', /^\/api\/journal$/, (_, q) => { const date = q.get('date') || undefined; const j = buildJournal(date); return { ...j, markdown: renderJournal(j) }; }],
+  ['POST', /^\/api\/journal$/, async (_, __, req) => { const b = await readBody(req); return writeJournal(b.date || undefined); }],
   ['GET', /^\/api\/companies$/, () => store.companies()],
   ['GET', /^\/api\/feeds$/, () => store.feeds()],
   ['GET', /^\/api\/companies\/find$/, (_, q) => store.findBoard({ slug: q.get('slug') || '', ats: q.get('ats') || '', name: q.get('name') || '' })],

package/app/server/linkedin-import.mjs

@@ -4,10 +4,13 @@
 // appended again.
 import fs from 'node:fs';
 import path from 'node:path';
-import { P, DATA_DIR } from '../../scraper/config.mjs';
-import { readExport, buildIndex, peopleCandidates, warmPaths, companyKey } from '../../scraper/linkedin.mjs';
+import { loadCriteria, P, DATA_DIR } from '../../scraper/config.mjs';
+import { readExport, buildIndex, peopleCandidates, warmPaths, companyKey, sameCompany } from '../../scraper/linkedin.mjs';
 import * as people from './people.mjs';
 import * as store from './store.mjs';
+import { writeJobNote } from '../../scraper/vault.mjs';
+import { scoreJob, normalizeTitle } from '../../scraper/score.mjs';
+import { htmlToText } from '../../scraper/sources.mjs';
 
 const isoDay = (d = new Date()) => d.toISOString().slice(0, 10);
 const daysAgo = (n) => isoDay(new Date(Date.now() - n * 864e5));
@@ -107,3 +110,97 @@ export function runImport(source, { since = daysAgo(90), roles = ['recruiter', '
 
   return summary;
 }
+
+// ---------------- applications and saved jobs, as notes ----------------
+// The export carries the person's own record of where they applied through LinkedIn and what they saved. Opt-in:
+// each becomes a note (or a line on the note that already exists), so the pipeline shows the search they were
+// already running. The posting itself is never fetched; the note carries the LinkedIn link for the person to open.
+const titleKey = (t) => normalizeTitle(t).replace(/[^a-z0-9 ]+/g, ' ').replace(/\s+/g, ' ').trim();
+const sameTitle = (a, b) => { const x = titleKey(a), y = titleKey(b); return !!x && !!y && (x === y || x.includes(y) || y.includes(x)); };
+const hash = (s) => { let h = 5381; for (const ch of String(s)) h = ((h * 33) ^ ch.charCodeAt(0)) >>> 0; return h.toString(16); };
+const noteText = (id) => { try { return fs.readFileSync(store.getJob(id).path, 'utf8'); } catch { return ''; } };
+// Empty or absent: a note written by hand or by an older version may not carry the field at all.
+const appliedOnEmpty = (id) => !/^- \*\*Applied on:\*\*\s*\S/m.test(noteText(id));
+const noteOnce = (id, line) => { if (!noteText(id).includes(line)) store.addNote(id, line, 'linkedin-export'); };
+
+function findNote(jobs, { company, title, url }) {
+  const clean = (u) => String(u || '').split('?')[0].replace(/\/$/, '');
+  const byUrl = url && jobs.find((j) => j.url && clean(j.url) === clean(url));
+  if (byUrl) return byUrl;
+  return jobs.filter((j) => sameCompany(j.company, company)).find((j) => sameTitle(j.title, title)) || null;
+}
+function stubFor(kind, r) {
+  const html = kind === 'application'
+    ? `<p>Applied through LinkedIn on ${r.date}. From the LinkedIn data export: the posting itself was not read, so there is no description or pay here. Open the link for the posting.</p>`
+    : `<p>Saved on LinkedIn on ${r.date}. From the LinkedIn data export: the posting itself was not read. Open the link for the posting.</p>`;
+  const job = {
+    id: `linkedin:${kind}:${hash(`${r.url || ''}|${r.company}|${r.title}|${r.date}`)}`, source: 'linkedin-export', company: r.company, title: r.title || 'Role not named in the export',
+    url: r.url || '', location: '', remote: false, posted: r.date, descriptionHtml: html, foundVia: kind === 'application' ? 'from the LinkedIn export: an application' : 'from the LinkedIn export: a saved job', addedBy: 'linkedin-export',
+  };
+  job.descriptionText = htmlToText(job.descriptionHtml);
+  return job;
+}
+
+/** What importing the applications and saved jobs would touch: per kind, the notes it would mark and the ones it would create. */
+export function planJobs(index, { since = index?.since || '', applications = false, saved = false } = {}) {
+  const jobs = store.listJobs();
+  const recent = (d) => !since || (d && d >= since);
+  const one = (rows, on) => {
+    const out = { matched: [], create: [], skipped: 0 };
+    if (!on) return out;
+    for (const r of rows || []) {
+      if (!recent(r.date) || !r.company) { out.skipped++; continue; }
+      const note = findNote(jobs, r);
+      if (note) out.matched.push({ id: note.id, status: note.status, date: r.date, company: r.company, title: r.title });
+      else out.create.push(r);
+    }
+    return out;
+  };
+  return { since, applications: one(index?.applications, applications), saved: one(index?.savedJobs, saved) };
+}
+
+/**
+ * Applications become notes at "applied" with the date; saved jobs become notes at "reviewing". A note that already
+ * exists gets the line and, for an application, the status and the date if it had none. Re-running changes nothing.
+ * The status is set via "linkedin-export": the person's own record is the evidence, so the human-only rule for agents
+ * does not apply, and the status log says where it came from.
+ */
+export function importJobs(source, { since = daysAgo(90), applications = false, saved = false, dry = false } = {}) {
+  const index = buildIndex(readExport(source), { since });
+  const plan = planJobs(index, { since: index.since, applications, saved });
+  const out = { since: index.since, dry, applications: { matched: 0, marked: 0, created: 0, skipped: plan.applications.skipped }, saved: { matched: 0, created: 0, skipped: plan.saved.skipped } };
+  // A profile with no criteria yet (the import can run before the interview) still gets its notes; they are scored later by a rescore.
+  let criteria; try { criteria = loadCriteria(); } catch { criteria = { titleTerms: {}, titleExclude: [], descTerms: {}, minScore: 0 }; }
+  const advanced = ['applied', 'interviewing', 'offer', 'rejected'];
+  for (const m of plan.applications.matched) {
+    out.applications.matched++;
+    if (dry) continue;
+    if (!advanced.includes(m.status)) { store.setStatus(m.id, 'applied', 'linkedin-export'); out.applications.marked++; }
+    if (appliedOnEmpty(m.id)) store.saveApplicationDraft(m.id, { field: 'Applied on', value: m.date });
+    noteOnce(m.id, `Applied through LinkedIn on ${m.date} (from the LinkedIn export).`);
+  }
+  for (const r of plan.applications.create) {
+    out.applications.created++;
+    if (dry) continue;
+    const job = stubFor('application', r);
+    const id = path.basename(writeJobNote(job, scoreJob(job, criteria), criteria), '.md');
+    store.cacheClear?.();
+    store.setStatus(id, 'applied', 'linkedin-export');
+    if (appliedOnEmpty(id)) store.saveApplicationDraft(id, { field: 'Applied on', value: r.date });
+  }
+  for (const m of plan.saved.matched) {
+    out.saved.matched++;
+    if (dry) continue;
+    noteOnce(m.id, `Saved on LinkedIn on ${m.date} (from the LinkedIn export).`);
+  }
+  for (const r of plan.saved.create) {
+    out.saved.created++;
+    if (dry) continue;
+    const job = stubFor('saved', r);
+    const id = path.basename(writeJobNote(job, scoreJob(job, criteria), criteria), '.md');
+    store.cacheClear?.();
+    store.setStatus(id, 'reviewing', 'linkedin-export');
+  }
+  store.cacheClear?.();
+  return out;
+}

package/app/server/mcp.mjs

@@ -19,7 +19,7 @@ export const TOOLS = [
   { name: 'list_snippets', description: 'The copy panel: the person\'s standard answers for application forms (name, email, phone, links, availability, salary answer, anything they added), grouped, from Profile/Snippets.md. Use these verbatim when drafting form answers; never invent a value that is empty here.', inputSchema: { type: 'object', properties: {} } },
   { name: 'list_people', description: 'The people in the search: recruiters, hiring managers, interviewers and referrals, one note each under People/, with role, company, email, last contact and the job notes they are on. Newest contact first.', inputSchema: { type: 'object', properties: {} } },
   { name: 'get_person', description: 'One person in full: the row plus their About text and dated Log of contacts.', inputSchema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } },
-  { name: 'import_linkedin', description: "Read the person's LinkedIn data export (the larger archive from linkedin.com/mypreferences/d/download-my-data, as a zip or an unpacked folder, given by local path) into the search: an index of who they know at which company (job notes then show connections), People notes for the recruiters and hiring managers who wrote since the date (with the thread as their log, linked to open job notes at that company). The archive is read in place and never copied. dry=true reports without writing; everyone=true also writes senders whose title is not a recruiting or hiring one. Default since: 90 days ago.", inputSchema: { type: 'object', properties: { source: { type: 'string', description: 'Local path to the zip or folder' }, since: { type: 'string', description: 'YYYY-MM-DD' }, everyone: { type: 'boolean' }, writePeople: { type: 'boolean' }, dry: { type: 'boolean' } }, required: ['source'] } },
+  { name: 'import_linkedin', description: "Read the person's LinkedIn data export (the larger archive from linkedin.com/mypreferences/d/download-my-data, as a zip or an unpacked folder, given by local path) into the search: an index of who they know at which company (job notes then show connections), People notes for the recruiters and hiring managers who wrote since the date (with the thread as their log, linked to open job notes at that company). The archive is read in place and never copied. dry=true reports without writing; everyone=true also writes senders whose title is not a recruiting or hiring one. applications=true turns the person's LinkedIn applications since the date into notes at applied with the date (or marks the note that exists); saved=true turns their saved jobs into notes at reviewing. The person's own export is the evidence, so these statuses are allowed here. Default since: 90 days ago.", inputSchema: { type: 'object', properties: { source: { type: 'string', description: 'Local path to the zip or folder' }, since: { type: 'string', description: 'YYYY-MM-DD' }, everyone: { type: 'boolean' }, writePeople: { type: 'boolean' }, applications: { type: 'boolean' }, saved: { type: 'boolean' }, dry: { type: 'boolean' } }, required: ['source'] } },
   { name: 'connections_at', description: "Who the person knows at a company, from the LinkedIn import: name, title, a guessed role (recruiter, hiring-manager, other), profile link, when connected. Empty before the first import (say so and offer import_linkedin). Use it before drafting an application or when a job note is discussed: a warm introduction beats a cold apply.", inputSchema: { type: 'object', properties: { company: { type: 'string' } }, required: ['company'] } },
   { name: 'add_person', description: 'Add a person (or recognise one already there, by email or name and company) and optionally put them on a job note. role: recruiter | hiring-manager | interviewer | referral | other. Give jobId to attach; context is a few words on the thread.', inputSchema: { type: 'object', properties: { name: { type: 'string' }, role: { type: 'string', enum: people.ROLES }, company: { type: 'string' }, email: { type: 'string' }, links: { type: 'string' }, about: { type: 'string' }, jobId: { type: 'string' }, context: { type: 'string' } }, required: ['name'] } },
   { name: 'attach_person', description: 'Put an existing person on a job note (a line under its People section) and the job on their Threads. Idempotent.', inputSchema: { type: 'object', properties: { jobId: { type: 'string' }, personId: { type: 'string' }, role: { type: 'string', enum: people.ROLES }, context: { type: 'string' } }, required: ['jobId', 'personId'] } },
@@ -116,7 +116,11 @@ export async function call(name, a = {}) {
     case 'list_snippets': return store.getSnippets();
     case 'list_people': return people.listPeople();
     case 'get_person': return people.getPerson(a.id);
-    case 'import_linkedin': return linkedin.runImport(a.source, { since: a.since, everyone: !!a.everyone, writePeople: a.writePeople !== false, dry: !!a.dry });
+    case 'import_linkedin': {
+      const r = linkedin.runImport(a.source, { since: a.since, everyone: !!a.everyone, writePeople: a.writePeople !== false, dry: !!a.dry });
+      if (a.applications || a.saved) r.jobs = linkedin.importJobs(a.source, { since: a.since, applications: !!a.applications, saved: !!a.saved, dry: !!a.dry });
+      return r;
+    }
     case 'connections_at': return linkedin.connectionsAt(a.company);
     case 'add_person': { const p = people.createPerson(a); if (a.jobId) people.attachPerson(a.jobId, p.id, { role: a.role, context: a.context }); return people.getPerson(p.id); }
     case 'attach_person': return people.attachPerson(a.jobId, a.personId, { role: a.role, context: a.context });

package/cli.mjs

@@ -40,10 +40,14 @@ const HELP = `tekjobs — a local job-search machine
   tekjobs import linkedin <zip|folder>   your LinkedIn data export into the search: who you know at each
                                          company, and the recruiters who wrote
                                          [--since YYYY-MM-DD] [--everyone] [--no-people] [--preview] [--dry]
+                                         [--applications] your LinkedIn applications as notes at "applied", with the date
+                                         [--saved] your saved jobs as notes at "reviewing"
   tekjobs up [--dev] [--port N]          start the API (and with --dev, Vite) detached: they stay up until \`down\`
   tekjobs down                           stop what \`up\` started
   tekjobs ps                             what \`up\` has running
   tekjobs board <slug> [--from ats] [--move]  where a failed board answers now; --move rewrites the watchlist row
+  tekjobs journal [YYYY-MM-DD] [--write]  the day's journal from the record (runs, found, decisions, mail); --write
+                                         puts it at the end of Logs/<date>.md, as every real scan does
   tekjobs serve                          the app + API on http://127.0.0.1:8787, in this terminal
   tekjobs mcp                            the MCP server on stdio (Claude Code, Codex, Cursor, Claude Desktop)
 
@@ -182,14 +186,31 @@ async function main() {
     if (!source) return console.error('Usage: tekjobs import linkedin <path to the export zip or unpacked folder> [--since YYYY-MM-DD] [--everyone] [--no-people] [--preview] [--dry]\nRequest the larger archive at https://www.linkedin.com/mypreferences/d/download-my-data');
     const li = await import('./app/server/linkedin-import.mjs');
     const o = { since: opt('--since') || undefined, everyone: rest.includes('--everyone'), writePeople: !rest.includes('--no-people'), dry: rest.includes('--dry') };
-    if (rest.includes('--preview')) return console.log(JSON.stringify(li.preview(source, o), null, 2));
+    const jobsOpt = { since: o.since, applications: rest.includes('--applications'), saved: rest.includes('--saved'), dry: o.dry };
+    if (rest.includes('--preview')) {
+      const p = li.preview(source, o);
+      if (jobsOpt.applications || jobsOpt.saved) p.jobs = li.importJobs(source, { ...jobsOpt, dry: true });
+      return console.log(JSON.stringify(p, null, 2));
+    }
     const s = li.runImport(source, o);
+    const jobs = jobsOpt.applications || jobsOpt.saved ? li.importJobs(source, jobsOpt) : null;
     console.log(`LinkedIn export read from ${s.source}${s.dry ? ' (dry run, nothing written)' : ''}`);
     console.log(`  ${s.counts.connections} connections indexed, ${s.counts.threads} conversations and ${s.counts.invitations} invitations since ${s.since}, ${s.counts.applications} applications, ${s.counts.savedJobs} saved jobs`);
     console.log(`  People: ${s.people.created} created, ${s.people.recognised} already there, ${s.people.attached} put on job notes, ${s.people.logged} log lines; ${s.people.skipped} senders skipped (not recruiters or hiring managers; --everyone includes them)`);
+    if (jobs) {
+      if (jobsOpt.applications) console.log(`  Applications: ${jobs.applications.matched} already had a note (${jobs.applications.marked} moved to applied), ${jobs.applications.created} notes created at applied, ${jobs.applications.skipped} before ${jobs.since} or without a company`);
+      if (jobsOpt.saved) console.log(`  Saved jobs: ${jobs.saved.matched} already had a note, ${jobs.saved.created} notes created at reviewing, ${jobs.saved.skipped} before ${jobs.since} or without a company`);
+    }
     if (!s.dry) console.log(`  Index: ${s.indexPath}. Job notes now show who you know at each company.`);
     return;
   }
+  if (cmd === 'journal') {
+    const { buildJournal, renderJournal, writeJournal } = await import('./scraper/journal.mjs');
+    const date = rest.find((x) => /^\d{4}-\d{2}-\d{2}$/.test(x));
+    if (rest.includes('--write')) { const r = writeJournal(date); console.log(r.markdown); console.log(`Written to ${r.file}`); return; }
+    console.log(renderJournal(buildJournal(date)));
+    return;
+  }
   if (cmd === 'board') {
     const slug = rest.find((x) => !x.startsWith('--') && x !== opt('--from'));
     if (!slug) return console.error('Usage: tekjobs board <slug> [--from <ats that failed>] [--move]');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurtekb/tekjobs",
-  "version": "0.45.0",
+  "version": "0.47.0",
   "description": "A local-first job-search machine: watches hundreds of company job boards, scores every posting against your profile, and files matches into a folder of markdown notes you own. Bring your own LLM through MCP.",
   "type": "module",
   "license": "MIT",

package/run.mjs

@@ -203,6 +203,8 @@ const logLines = [
 if (!DRY) {
   appendLog(logLines);
   writeDashboard(summary);
+  // The day's journal is rebuilt from the record after every real run, so the log note ends with the day so far.
+  try { const { writeJournal } = await import('./scraper/journal.mjs'); writeJournal(); } catch (e) { console.log(`  journal not written: ${e.message}`); }
 }
 console.log(logLines.join('\n'));
 // The top of the list, with where each one stands. Ranking ignores status on purpose (the score is about the

package/scraper/journal.mjs

@@ -0,0 +1,114 @@
+// The daily journal: what happened in the search on one day, read from the record itself and written as the last
+// section of that day's log note. Runs (from the log's own run sections), what was found, every decision made
+// (status moves, with who made them), mail confirmed or dismissed, and notes added. Nothing is stored twice: the
+// section is rebuilt from the notes each time and replaces the previous one, so a day's journal is always the
+// day's whole story. The site promises that the notes are the record; this is the record read back as a day.
+import fs from 'node:fs';
+import path from 'node:path';
+import { P, DATA_DIR } from './config.mjs';
+
+export const JOURNAL_HEADING = '## Journal';
+const isoDay = (d = new Date()) => d.toISOString().slice(0, 10);
+
+const readFm = (text) => {
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const out = {};
+  if (m) for (const line of m[1].split(/\r?\n/)) { const i = line.indexOf(':'); if (i > 0) out[line.slice(0, i).trim()] = line.slice(i + 1).trim().replace(/^"(.*)"$/, '$1'); }
+  return out;
+};
+
+/** The day's events, as data. `date` is YYYY-MM-DD; today by default. */
+export function buildJournal(date = isoDay()) {
+  const found = [], moves = [], notes = [];
+  if (fs.existsSync(P.jobs)) {
+    for (const f of fs.readdirSync(P.jobs).filter((x) => x.endsWith('.md'))) {
+      let text; try { text = fs.readFileSync(path.join(P.jobs, f), 'utf8'); } catch { continue; }
+      const fm = readFm(text);
+      const id = f.replace(/\.md$/, '');
+      const row = { id, company: fm.company || '', title: fm.title || '', score: Number(fm.score) || 0, status: fm.status || 'new' };
+      if (fm.found === date) found.push(row);
+      for (const m of text.matchAll(/^- (\d{4}-\d{2}-\d{2}) — (.*?) → \*\*([a-z]+)\*\*(?: \(([^)]*)\))? \(via ([^)]+)\)/gm)) {
+        if (m[1] === date) moves.push({ ...row, from: m[2], to: m[3], reason: m[4] || '', via: m[5] });
+      }
+      for (const m of text.matchAll(/^- (\d{4}-\d{2}-\d{2}) \(([^)]+)\): (.+)$/gm)) {
+        if (m[1] === date) notes.push({ ...row, via: m[2], text: m[3].slice(0, 160) });
+      }
+    }
+  }
+  // Mail: items confirmed or dismissed on the day, from the check's own state.
+  let mail = { confirmed: 0, dismissed: 0, items: [] };
+  try {
+    const d = JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'mail-check.json'), 'utf8'));
+    for (const i of d.items || []) {
+      const at = i.resolved?.at ? String(i.resolved.at).slice(0, 10) : '';
+      if (at !== date) continue;
+      if (i.state === 'confirmed') mail.confirmed++; else if (i.state === 'dismissed') mail.dismissed++;
+      mail.items.push({ company: i.company || '', role: i.role || '', kind: i.kind || '', state: i.state, status: i.resolved?.status || '' });
+    }
+  } catch { /* no mail state */ }
+  // Runs: the log's own "## Run" sections for the day.
+  const runs = [];
+  const logFile = path.join(P.logs, `${date}.md`);
+  if (fs.existsSync(logFile)) {
+    const text = fs.readFileSync(logFile, 'utf8');
+    for (const m of text.matchAll(/^## Run (.+?)\n([\s\S]*?)(?=^## |(?![\s\S]))/gm)) {
+      const b = m[2];
+      const g = (re) => (b.match(re) || [])[1];
+      runs.push({ when: m[1].trim(), boardsOk: Number(g(/Boards: (\d+)\//)) || 0, boardsTotal: Number(g(/Boards: \d+\/(\d+)/)) || 0, scanned: Number((g(/postings scanned: ([\d,]+)/) || '0').replace(/,/g, '')), newNotes: Number(g(/\*\*new: (\d+)\*\*/)) || 0, closed: Number(g(/closed: (\d+)/)) || 0, dry: /\(dry\)/.test(m[1]) });
+    }
+  }
+  const byTo = {};
+  for (const m of moves) (byTo[m.to] ||= []).push(m);
+  return { date, runs, found, moves, byTo, notes, mail, empty: runs.length === 0 && found.length === 0 && moves.length === 0 && notes.length === 0 && mail.items.length === 0 };
+}
+
+const line = (r) => `${r.company} — ${r.title}`;
+const plural = (n, s, p = `${s}s`) => `${n} ${n === 1 ? s : p}`;
+
+/** The journal as the markdown section the log note carries. */
+export function renderJournal(j) {
+  const out = [JOURNAL_HEADING, ''];
+  if (j.empty) { out.push('Nothing happened in the search today: no run, no decisions, no mail.', ''); return out.join('\n'); }
+  const real = j.runs.filter((r) => !r.dry);
+  if (real.length) {
+    const last = real[real.length - 1];
+    out.push(`- **Scan**: ${plural(real.length, 'run')}; the last read ${last.boardsOk}/${last.boardsTotal} boards and ${last.scanned.toLocaleString('en-US')} postings, wrote ${plural(last.newNotes, 'new note')}, closed ${last.closed}.`);
+  } else if (j.runs.length) out.push(`- **Scan**: ${plural(j.runs.length, 'dry run')} only; nothing written.`);
+  if (j.found.length) {
+    const top = [...j.found].sort((a, b) => b.score - a.score).slice(0, 5);
+    out.push(`- **Found**: ${plural(j.found.length, 'new match', 'new matches')}. Best: ${top.map((r) => `${line(r)} (${r.score})`).join('; ')}.`);
+  }
+  const order = ['reviewing', 'applying', 'ready', 'applied', 'interviewing', 'offer', 'rejected', 'passed', 'new'];
+  const words = { reviewing: 'shortlisted', applying: 'started applying to', ready: 'made ready', applied: 'applied to', interviewing: 'interviewing at', offer: 'offer from', rejected: 'rejected by', passed: 'passed on', new: 'put back to new' };
+  for (const to of order) {
+    const ms = j.byTo[to]; if (!ms?.length) continue;
+    const who = [...new Set(ms.map((m) => m.via))].join(', ');
+    const names = ms.slice(0, 6).map((m) => `${line(m)}${m.reason ? ` (${m.reason})` : ''}`).join('; ');
+    out.push(`- **${words[to] ? words[to][0].toUpperCase() + words[to].slice(1) : to}**: ${ms.length}${ms.length > 6 ? `, including` : ''} ${names}${ms.length > 6 ? ` and ${ms.length - 6} more` : ''} (via ${who}).`);
+  }
+  if (j.mail.items.length) {
+    const kinds = {};
+    for (const i of j.mail.items.filter((i) => i.state === 'confirmed')) kinds[i.kind] = (kinds[i.kind] || 0) + 1;
+    const kindText = Object.entries(kinds).map(([k, n]) => `${n} ${k}`).join(', ');
+    out.push(`- **Mail**: ${plural(j.mail.confirmed, 'item')} confirmed${kindText ? ` (${kindText})` : ''}, ${j.mail.dismissed} dismissed.`);
+  }
+  const human = j.notes.filter((n) => n.via !== 'app' || true).length;
+  if (human) out.push(`- **Notes**: ${plural(j.notes.length, 'line')} added across ${new Set(j.notes.map((n) => n.id)).size} job notes.`);
+  out.push('');
+  return out.join('\n');
+}
+
+/** Write (or rewrite) the day's Journal section at the end of Logs/<date>.md. Returns the file and the text. */
+export function writeJournal(date = isoDay()) {
+  const j = buildJournal(date);
+  const section = renderJournal(j);
+  fs.mkdirSync(P.logs, { recursive: true });
+  const file = path.join(P.logs, `${date}.md`);
+  let text = fs.existsSync(file) ? fs.readFileSync(file, 'utf8') : `---\ntype: log\ndate: ${date}\n---\n# ${date} — scraper log\n\n`;
+  // Replace an earlier journal for the day; it is always the last section.
+  const i = text.indexOf(`\n${JOURNAL_HEADING}\n`);
+  if (i >= 0) text = text.slice(0, i + 1);
+  if (!text.endsWith('\n\n')) text = text.replace(/\n*$/, '\n\n');
+  fs.writeFileSync(file, text + section + '\n');
+  return { file, journal: j, markdown: section };
+}