@timurtekb/tekjobs 0.24.1

package/scraper/profile.mjs

@@ -0,0 +1,186 @@
+// Profile folder lifecycle: create it, import a resume, report what is still missing, save the interview's output.
+// Shared by the CLI (cli.mjs), the API server and the MCP server.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { P, VAULT, rememberProfileDir, loadCriteria } from './config.mjs';
+import { extractText } from './resume.mjs';
+
+const STARTER = fileURLToPath(new URL('./starter/', import.meta.url));
+const today = () => new Date().toISOString().slice(0, 10);
+
+/** Create the folder layout and starter notes in `dir` (default: the resolved profile dir). Never overwrites. */
+export function initProfile(dir = VAULT) {
+  const made = [];
+  const mk = (rel, content) => {
+    const file = path.join(dir, rel);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    if (fs.existsSync(file)) return;
+    fs.writeFileSync(file, content);
+    made.push(rel);
+  };
+  for (const d of ['Profile', 'Targets', 'Jobs', 'Logs', '.tekjobs']) fs.mkdirSync(path.join(dir, d), { recursive: true });
+  mk('Profile/Profile.md', fs.readFileSync(path.join(STARTER, 'profile.md'), 'utf8').replace('{{date}}', today()));
+  mk('Targets/Search Criteria.md', criteriaNote(fs.readFileSync(path.join(STARTER, 'criteria.json'), 'utf8').trim()));
+  mk('Targets/Companies.md', companiesNote(fs.readFileSync(path.join(STARTER, 'companies-table.md'), 'utf8')));
+  mk('README.md', readme(dir));
+  rememberProfileDir(dir);
+  return { dir, made };
+}
+
+/** Copy a resume into Profile/ and write its extracted text beside it as `Resume - Source.md`. */
+export async function importResume(file, dir = VAULT) {
+  if (!fs.existsSync(file)) throw Object.assign(new Error(`No such file: ${file}`), { status: 404 });
+  const text = await extractText(file);
+  if (text.trim().length < 200) throw Object.assign(new Error(`The resume text came out at ${text.trim().length} characters; a resume is at least 200. If it is a scanned PDF, export it as text or DOCX first.`), { status: 422 });
+  const profileDir = path.join(dir, 'Profile');
+  fs.mkdirSync(profileDir, { recursive: true });
+  const dest = path.join(profileDir, `Resume - Original${path.extname(file).toLowerCase()}`);
+  if (path.resolve(file) !== path.resolve(dest)) fs.copyFileSync(file, dest);
+  const md = `---\ntype: resume-source\nimported: ${today()}\noriginal: ${JSON.stringify(path.basename(file))}\n---\n# Resume, as imported\n\n> Text extracted from the original by \`tekjobs resume\`. The interview reads this; the polished resume drafts live in their own notes.\n\n${text}\n`;
+  fs.writeFileSync(path.join(profileDir, 'Resume - Source.md'), md);
+  return { original: dest, source: path.join(profileDir, 'Resume - Source.md'), chars: text.length };
+}
+
+/** What the onboarding still needs. Drives the CLI, the app's Onboarding screen and the MCP status tool. */
+export function onboardingStatus(dir = VAULT) {
+  const exists = (rel) => fs.existsSync(path.join(dir, rel));
+  const read = (rel) => { try { return fs.readFileSync(path.join(dir, rel), 'utf8'); } catch { return ''; } };
+  const profile = read('Profile/Profile.md');
+  const profileFilled = !!profile && !/^status: draft$/m.test(profile) && !/\(The interview fills this in/.test(profile);
+  let criteria = null; let criteriaFilled = false;
+  try { criteria = loadCriteria(); criteriaFilled = Object.keys(criteria.titleTerms || {}).length > 0; } catch { /* absent or invalid */ }
+  const jobs = exists('Jobs') ? fs.readdirSync(path.join(dir, 'Jobs')).filter((f) => f.endsWith('.md')).length : 0;
+  const steps = [
+    { id: 'folder', label: 'Profile folder exists', done: exists('Targets/Search Criteria.md') && exists('Targets/Companies.md'), how: 'tekjobs init [dir]' },
+    { id: 'resume', label: 'Resume imported', done: exists('Profile/Resume - Source.md') || (exists('Profile') && fs.readdirSync(path.join(dir, 'Profile')).some((f) => /^Resume.*\.md$/i.test(f))), how: 'tekjobs resume <file.pdf|docx|md>' },
+    { id: 'profile', label: 'Profile written by the interview', done: profileFilled, how: 'Run the interview: in Claude Code (or any MCP client connected to tekjobs), ask it to call onboarding_materials and interview you.' },
+    { id: 'criteria', label: 'Search criteria filled (title terms set)', done: criteriaFilled, how: 'The interview writes them; or edit Targets/Search Criteria.md.' },
+    { id: 'scan', label: 'First scan has run', done: jobs > 0, how: 'tekjobs scan, or the Runs screen.' },
+  ];
+  return { dir, steps, complete: steps.every((s) => s.done), jobs, profilePath: path.join(dir, 'Profile', 'Profile.md') };
+}
+
+/** Everything the interviewing LLM needs in one call: resume text, current notes, and the script to follow. */
+export function onboardingMaterials(dir = VAULT) {
+  const read = (rel) => { try { return fs.readFileSync(path.join(dir, rel), 'utf8'); } catch { return ''; } };
+  let criteriaRaw = '';
+  const m = read('Targets/Search Criteria.md').match(/```json\s*\n([\s\S]*?)\n```/); if (m) criteriaRaw = m[1];
+  return {
+    status: onboardingStatus(dir),
+    resumeText: read('Profile/Resume - Source.md').replace(/^---[\s\S]*?---\n/, ''),
+    profile: read('Profile/Profile.md'),
+    criteria: criteriaRaw,
+    script: INTERVIEW_SCRIPT,
+  };
+}
+
+export function saveProfile(markdown, dir = VAULT) {
+  if (!markdown || markdown.trim().length < 100) throw Object.assign(new Error('Profile is too short to save; write the full note.'), { status: 400 });
+  let md = markdown.replace(/^status: draft$/m, 'status: interviewed');
+  if (!/^---\n/.test(md)) md = `---\ntype: profile\nupdated: ${today()}\nstatus: interviewed\n---\n${md}`;
+  md = md.replace(/^updated: .*$/m, `updated: ${today()}`);
+  const file = path.join(dir, 'Profile', 'Profile.md');
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  if (fs.existsSync(file)) fs.copyFileSync(file, path.join(dir, 'Profile', `Profile.before-${today()}.md`));
+  fs.writeFileSync(file, md);
+  return { saved: file };
+}
+
+/** Fetch a public page (portfolio, GitHub, LinkedIn export is a file, not a URL) as text for the interview to summarize. */
+export async function fetchLink(url, { maxChars = 20000 } = {}) {
+  const u = new URL(url);
+  if (!/^https?:$/.test(u.protocol)) throw Object.assign(new Error('Only http(s) URLs.'), { status: 400 });
+  // A link that does not resolve should say so in words the interviewer can pass on, not "fetch failed".
+  let res;
+  try { res = await fetch(u, { headers: { 'user-agent': 'TekJobs/1.0 (onboarding; fetching a link the user gave)', accept: 'text/html,text/plain,application/json' }, signal: AbortSignal.timeout(20000), redirect: 'follow' }); }
+  catch (e) { const why = e.name === 'TimeoutError' ? 'no answer in 20 seconds' : (e.cause && e.cause.code) || e.message; throw Object.assign(new Error(`Could not fetch ${u.hostname}: ${why}. Ask the person to check the link, or to paste the page's text instead.`), { status: 502 }); }
+  const html = await res.text();
+  const text = html.replace(/<script[\s\S]*?<\/script>|<style[\s\S]*?<\/style>/gi, '').replace(/<\/(p|div|li|h[1-6]|tr|section|article)>/gi, '\n').replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ').replace(/&amp;/g, '&').replace(/[ \t]+/g, ' ').replace(/\n\s*\n+/g, '\n\n').trim();
+  return { url, status: res.status, chars: text.length, text: text.slice(0, maxChars), truncated: text.length > maxChars };
+}
+
+const INTERVIEW_SCRIPT = `You are onboarding a job seeker into TekJobs. Goal: write Profile/Profile.md and the criteria JSON so the daily scan finds the right roles for THIS person. Be direct and specific; no filler.
+
+1. Read resumeText. Extract: name, location, current role and dates, the last three roles, stack and tools, quantified outcomes (numbers, scale, team size), and the through-line of the career. If the resume is missing, ask the user to run \`tekjobs resume <file>\` or paste it.
+2. Ask the user, in ONE message, only what the resume cannot tell you (skip anything already clear):
+   - Target titles (2 to 6). Offer a guess from the resume and let them edit it.
+   - Seniority they are applying at (senior / staff / lead / principal / manager).
+   - Work mode: remote only, hybrid, on-site; and where they live.
+   - Pay floor (base), and a stretch band under it they would still look at.
+   - Must-have keywords (stack, domain) and hard exclusions (titles, industries, company types).
+   - Company stage or size preference, if any.
+   - Links: portfolio, GitHub, personal site. Fetch each with fetch_link and fold what you learn into the profile. LinkedIn: ask for their data-export ZIP contents or a pasted summary; never scrape a LinkedIn page.
+   - Earliest start date.
+3. Write Profile/Profile.md using the existing note's headings (Basics · What you are, in three sentences · Target roles table with tiers A/B · Constraints & preferences · Proof points · Documents). Proof points are one line each, with numbers. Call save_profile with the full markdown.
+4. Build the criteria from the current JSON (keep every key). Set:
+   - titleTerms: exact lowercase substrings that appear in real job titles for the target roles, weighted 40 for exact-fit titles down to ~20 for adjacent ones. Include common variants ("front-end", "frontend", "front end").
+   - titleExclude: add the user's hard exclusions as lowercase substrings.
+   - descTerms: 15 to 30 stack/domain words with weights 2 to 6.
+   - salary.minAnnual and salary.stretchAnnual as integers (or null if the user declines).
+   - location.requireRemote true only if the user said remote only; add their metro to bayAreaTerms with bayAreaBoost 12 if hybrid there is acceptable.
+   Call set_criteria with the full JSON string. It is validated before writing.
+5. Call run_scan with dry=true and poll scan_status every few seconds until running is false (two to three minutes). A dry run writes no notes, so do not use search_jobs yet: call scan_preview limit=15 and show the user the top matches with score, pay band and one reason each. Ask whether the list looks right. Adjust the criteria once if it does not (set_criteria, then another dry run_scan and scan_preview). When it does, call run_scan with dry=false and poll scan_status until it finishes; that run writes the notes, and search_jobs and the app's Today page work from then on.
+6. Finish by telling the user where things live: Profile/Profile.md, Targets/Search Criteria.md, Jobs/. Remind them the daily scan runs on its own from here.`;
+
+function criteriaNote(json) {
+  return `---
+type: config
+updated: ${today()}
+---
+# Search Criteria
+
+> **The scraper reads the JSON block below.** The onboarding interview fills it from your resume and your answers; after that, edit it here. Weights are additive points. A job needs \`minScore\` to get its own note in \`Jobs/\`.
+
+How scoring works:
+- **titleTerms** — best single match in the job title counts fully, each extra match adds 5. Empty until the interview runs.
+- **titleExclude** — any hit in the title drops the job entirely.
+- **noTitleMatchPenalty** — a posting whose title matches nothing in \`titleTerms\` takes this hit, so location and recency alone can't carry it over the bar.
+- **descTerms** — each term found in the description adds its weight (capped at \`descCap\`).
+- **seniority** — senior/staff/lead/principal adds; junior/intern subtracts.
+- **location** — remote adds; with \`requireRemote\` on, anything not remote takes \`notRemotePenalty\` and drops out. Clearly non-US-only listings subtract heavily.
+- **salary** — a stated range at or above \`minAnnual\` adds; between \`stretchAnnual\` and \`minAnnual\` is the stretch band (small penalty, kept visible); below subtracts. No stated range is neutral.
+- **recency** — posted within 7 days adds, over 90 days subtracts.
+- **openSources** — aggregator feeds that need no company slug. Set one to \`false\` to drop it. \`wellfound\` and \`builtin\` read those sites' remote listing pages (no API), searched by design-engineering roles; both lose to the same job from its ATS when both turn up.
+- **email** — job alert emails you save into the \`Inbox\` folder of this profile, as \`.eml\`. This is how the boards with no public API get in: LinkedIn, Indeed, Otta and Wellfound all send alerts, and an email in your own mailbox is your own data. Nothing contacts those sites — it reads files you put there, and the links are for you to open. Links to Greenhouse, Lever, Ashby and Workday are picked up from any sender. Rows are thin (a title, a company, usually a location), so they score below the same job from an ATS and lose to it when both turn up.
+- **adzuna** — the one source that needs a key. Set \`ADZUNA_APP_ID\` and \`ADZUNA_APP_KEY\` in the environment (free at developer.adzuna.com), turn \`openSources.adzuna\` on, and it searches your top \`titleTerms\` in each country under \`adzuna.countries\`. It reaches listings that never appear on a company ATS board, but its descriptions come back as snippets, so those rows score lower than the same job fetched from its ATS.
+- **usajobs** — every US federal posting. Set \`USAJOBS_API_KEY\` and \`USAJOBS_EMAIL\` (free at developer.usajobs.gov; the email is the one the key is registered to) and turn \`openSources.usajobs\` on. Unlike Adzuna it returns the whole description, so these rows score on equal footing, and it carries a real application deadline.
+
+\`\`\`json
+${json}
+\`\`\`
+`;
+}
+
+function companiesNote(table) {
+  return `---
+type: config
+updated: ${today()}
+---
+# Company Watchlist
+
+> **The scraper reads the table below.** Add a row to start watching a company; delete a row to stop. \`ATS\` names the platform; \`Slug\` is the company's board token on that platform (for Greenhouse, Lever, Ashby: the part of the URL after \`boards.greenhouse.io/\`, \`jobs.lever.co/\`, or \`jobs.ashbyhq.com/\`). Tier is yours (A = dream, B = strong, C = fine). The scraper rewrites the \`Status\` column on every run: \`ok · N\` or \`bad-slug\`.
+
+Platforms: \`greenhouse\`, \`lever\`, \`ashby\`, \`workday\` (slug \`host/tenant/site\`), \`rippling\`, \`smartrecruiters\`, \`workable\`, \`bamboohr\`, \`breezy\`, \`personio\`, \`teamtailor\`, \`eightfold\` (slug \`host/domain\`), and single-company fetchers \`atlassian\`, \`github\`, \`spotify\`, \`amazon\`, \`google\`, \`apple\` (slug \`-\`; Google and Apple are read from their career pages, keyword-searched, mostly on-site roles). Aggregators with no slug are toggled in [[Targets/Search Criteria]] under \`openSources\`.
+
+This starter list is the community registry: tech companies whose boards answer without a login. Cut it to what you care about, or add your own.
+
+${table}`;
+}
+
+function readme(dir) {
+  return `# TekJobs profile folder
+
+This folder is your job search: profile, resume, criteria, watchlist, one note per matched job, and logs. It is plain markdown. Open it in Obsidian or any editor; the TekJobs app and its MCP server read and write the same files.
+
+- \`Profile/Profile.md\` — who you are and what you want (written by the onboarding interview)
+- \`Profile/Resume - Source.md\` — your resume as text
+- \`Targets/Search Criteria.md\` — how postings are scored (JSON block)
+- \`Targets/Companies.md\` — which boards are watched
+- \`Jobs/\` — one note per match; change \`status:\` to move it through the pipeline
+- \`Logs/\` — what each scan found
+- \`.tekjobs/\` — scan state (safe to delete; the next scan rebuilds it, existing notes are never overwritten)
+
+Folder: ${dir}
+`;
+}

package/scraper/rescore.mjs

@@ -0,0 +1,236 @@
+// Apply a change in scoring weights to notes that already exist.
+//
+// Scores are written into a note's frontmatter when the note is created and never recomputed, so a change to
+// the criteria only reaches matches found after it. This brings the existing ones forward.
+//
+// It does NOT re-run scoreJob against the note. It cannot: a note stores at most `maxDescriptionChars` of the
+// posting, so on this vault 194 of 338 open notes hold less text than the scan scored them on, and rescoring
+// from the note would quietly lower every one of them. Instead it recomputes only the three components that
+// are exactly derivable from frontmatter — title, recency and pay — and applies the difference to the stored
+// score. Everything else (description keywords, seniority, location) is unchanged by a weight edit and
+// cancels out, so the arithmetic is exact rather than approximate.
+//
+// Recency is measured at the age the posting had when it was found, not today's age. The stored score is a
+// snapshot taken at discovery; re-dating it would make every score drift daily and mean something different
+// from the number beside it in an older note.
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { P, loadCriteria } from './config.mjs';
+import { scoreJob } from './score.mjs';
+
+/**
+ * A short fingerprint of every criteria key the scorer reads.
+ *
+ * Stamped into a note as `weights:` so a note knows which rules produced its score. Without it a rescore has
+ * no way to tell an already-adjusted note from an untouched one, and running the command twice would apply
+ * the same delta twice — which is exactly the kind of quiet corruption this vault's never-rewrite rule
+ * exists to prevent.
+ */
+export function weightsFingerprint(c = {}) {
+  const relevant = {
+    titleTerms: c.titleTerms, titleExclude: c.titleExclude, titleExtraPer: c.titleExtraPer,
+    titleExtraCap: c.titleExtraCap, noTitleMatchPenalty: c.noTitleMatchPenalty,
+    seniority: c.seniority, descTerms: c.descTerms, descCap: c.descCap,
+    location: c.location, salary: c.salary, recency: c.recency,
+  };
+  // Keys sorted at every level. (An array replacer in JSON.stringify whitelists keys at every depth too, so
+  // the earlier `JSON.stringify(relevant, topLevelKeys)` dropped nearly all the nested values: a criteria
+  // set with a different pay floor or different title weights hashed the same. Found 2026-09-22 when a
+  // preset with a 180k floor reported itself identical to the 220k active set.)
+  const stable = JSON.stringify(sortKeys(relevant));
+  return crypto.createHash('sha1').update(stable).digest('hex').slice(0, 8);
+}
+const sortKeys = (v) => (Array.isArray(v) ? v.map(sortKeys) : v && typeof v === 'object' ? Object.fromEntries(Object.keys(v).sort().map((k) => [k, sortKeys(v[k])])) : v);
+
+const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
+
+/** Title points under one set of weights. `extraCap` null means the old, uncapped behaviour. */
+export function titlePoints(title = '', c = {}, extraCap) {
+  const hits = Object.entries(c.titleTerms || {})
+    .filter(([t]) => title.toLowerCase().includes(t.toLowerCase()))
+    .sort((a, b) => b[1] - a[1]);
+  if (!hits.length) return c.noTitleMatchPenalty ?? -40;
+  const per = c.titleExtraPer ?? 5;
+  const extra = (hits.length - 1) * per;
+  return hits[0][1] + (extraCap == null ? extra : Math.min(extra, extraCap));
+}
+
+/** Recency points for an age in days. `withDays2` false reproduces the old four-bucket scale. */
+export function recencyPoints(days, r = {}, withDays2 = true) {
+  if (!Number.isFinite(days)) return 0;
+  if (withDays2 && days <= 2) return r.days2 ?? r.days7 ?? 0;
+  if (days <= 7) return r.days7 ?? 0;
+  if (days <= 30) return r.days30 ?? 0;
+  if (days <= 90) return r.days90 ?? 0;
+  return r.older ?? 0;
+}
+
+/** Pay points. `scaled` false reproduces the old flat bonus for clearing the floor. */
+export function payPoints(salaryMax, S = {}, scaled = true) {
+  if (!S.minAnnual || !salaryMax) return 0;
+  if (salaryMax >= S.minAnnual) {
+    const base = S.meetsBonus ?? 10;
+    if (!scaled) return base;
+    const over = Math.max(0, salaryMax - S.minAnnual);
+    return base + Math.min(Math.round((over / 10000) * (S.abovePer10k ?? 1)), S.aboveCap ?? 15);
+  }
+  if (S.stretchAnnual && salaryMax >= S.stretchAnnual) return S.stretchPenalty ?? -8;
+  return S.belowPenalty ?? -30;
+}
+
+/**
+ * @param {object} opts
+ * @param {boolean} opts.dry   report without writing
+ * @param {object}  opts.before the criteria the existing scores were computed under
+ * @param {object}  [opts.now]  the criteria to move to; the active note when omitted. A preview passes a
+ *                              proposed set here with dry=true and reads `changes` without writing anything.
+ */
+export function rescore({ dry = false, before = null, stampOnly = false, now: proposed = null } = {}) {
+  const now = proposed || loadCriteria();
+  const fingerprint = weightsFingerprint(now);
+
+  // Record the current weights against every note without touching a score. For a vault whose notes were
+  // brought forward some other way, so the first real rescore does not adjust them a second time.
+  if (stampOnly) {
+    const files = fs.readdirSync(P.jobs).filter((f) => f.endsWith('.md'));
+    let stamped = 0;
+    for (const f of files) {
+      const file = path.join(P.jobs, f);
+      const text = fs.readFileSync(file, 'utf8');
+      if (new RegExp(`^weights: ${fingerprint}$`, 'm').test(text)) continue;
+      if (!dry) fs.writeFileSync(file, stampWeights(text, fingerprint));
+      stamped++;
+    }
+    return { total: files.length, changed: stamped, changes: [], fingerprint, stampOnly: true };
+  }
+
+  // `before` is required, and deliberately has no default.
+  //
+  // A note records the score it was given but not the weights that produced it, so nothing here can work out
+  // what has already been applied. Guessing the previous weights from the current ones would make the command
+  // silently double-apply on a second run and quietly corrupt every score in the vault. Until a note carries
+  // a fingerprint of the weights that scored it, the caller has to say what changed.
+  if (!before) {
+    throw Object.assign(
+      new Error('rescore needs the previous criteria: a note does not record which weights scored it, so running without them would double-apply. Pass --from <old-criteria.json>.'),
+      { status: 400 },
+    );
+  }
+  const old = before;
+
+  const files = fs.readdirSync(P.jobs).filter((f) => f.endsWith('.md'));
+  const changes = [];
+  for (const f of files) {
+    const file = path.join(P.jobs, f);
+    let text = fs.readFileSync(file, 'utf8');
+    const fm = (k) => (text.match(new RegExp('^' + k + ': (.*)$', 'm')) || [, ''])[1].replace(/^"|"$/g, '').trim();
+    const stored = num(fm('score'));
+    if (!stored) continue;
+    // Already at these weights: nothing to do, and re-applying the delta would be the bug.
+    if (fm('weights') === fingerprint) continue;
+
+    const title = fm('title');
+    const posted = fm('posted');
+    const found = fm('found');
+    // The age the posting had when the scan scored it, not its age today.
+    const ageAtScan = posted && found ? (Date.parse(found) - Date.parse(posted)) / 864e5 : NaN;
+    const salaryMax = num(fm('salary_max'));
+
+    const delta =
+      (titlePoints(title, now, now.titleExtraCap ?? 10) - titlePoints(title, old, old.titleExtraCap)) +
+      (recencyPoints(ageAtScan, now.recency, true) - recencyPoints(ageAtScan, old.recency, false)) +
+      (payPoints(salaryMax, now.salary, true) - payPoints(salaryMax, old.salary, false));
+
+    const updated = Math.round(stored + delta);
+    if (delta) changes.push({ file: f, company: fm('company'), title, stored, updated, delta });
+    if (!dry) {
+      // The stamp is written even when the delta is zero: the note is at these weights either way, and
+      // recording that is what makes a second run a no-op.
+      fs.writeFileSync(file, stampWeights(text.replace(/^score: .*$/m, `score: ${updated}`), fingerprint));
+    }
+  }
+  return { total: files.length, changed: changes.length, changes, fingerprint };
+}
+
+/**
+ * Score every note again from what the note holds, under the current criteria (or a proposed set).
+ *
+ * This is the rescore for a rule change the delta method cannot express: location terms, penalties,
+ * description keywords, seniority words. The job is rebuilt from the note's frontmatter and its Job description
+ * section and put through scoreJob with recency judged at the day the note was found. One component is
+ * carried over rather than recomputed: description points on a note whose description was truncated at
+ * write time, because the scan saw more text than the note keeps and re-reading the shorter text would lower
+ * the score for no change in the rules. Notes already stamped with the target weights are left alone.
+ *
+ * Writes, when not dry: `score:`, `pay_band:`, `weights:`, the "Why it matched" section, and a Status log line
+ * on every note whose score moved. Nothing else in the note is touched.
+ */
+export function rescoreFull({ dry = false, now: proposed = null } = {}) {
+  const criteria = proposed || loadCriteria();
+  const fingerprint = weightsFingerprint(criteria);
+  const files = fs.readdirSync(P.jobs).filter((f) => f.endsWith('.md'));
+  const changes = [];
+  let seen = 0, skipped = 0;
+  for (const f of files) {
+    const file = path.join(P.jobs, f);
+    let text = fs.readFileSync(file, 'utf8');
+    const fm = (k) => (text.match(new RegExp('^' + k + ': (.*)$', 'm')) || [, ''])[1].replace(/^"|"$/g, '').trim();
+    if (fm('weights') === fingerprint) { skipped++; continue; }
+    if (!/^score: /m.test(text)) continue;
+    seen++;
+    const section = (h) => (text.match(new RegExp(`^## ${h}[ \\t]*\\n([\\s\\S]*?)(?=^## |(?![\\s\\S]))`, 'm')) || [, ''])[1];
+    const descRaw = section('Job description');
+    const truncated = /^>.*truncated/m.test(descRaw);
+    const description = descRaw.replace(/^>.*$/gm, '').trim();
+    const stored = num(fm('score'));
+    const found = fm('found');
+    const job = {
+      title: fm('title'), company: fm('company'), location: fm('location'), remote: fm('remote') === 'true',
+      descriptionText: description, salary: fm('salary'), salaryMax: num(fm('salary_max')), posted: fm('posted') || null, department: fm('department'),
+    };
+    // The scan runs in the morning; a date-only `found` would put it at midnight and shift a two-day-old
+    // posting into the fresher tier, so the scan's own hour is assumed.
+    const scored = scoreJob(job, criteria, { now: found ? Date.parse(found) + 14.5 * 3600e3 : Date.now() });
+    let score = scored.score;
+    let reasons = scored.reasons;
+    // A note that holds less than the scan read (truncated, or no description at all, as some boards give
+    // none through their API) keeps the description points the scan awarded.
+    if ((truncated || !description) && !scored.excluded) {
+      const oldLine = (section('Why it matched').match(/^- (description \+(\d+):.*)$/m) || []);
+      const newLine = reasons.findIndex((r) => r.startsWith('description +'));
+      const newPts = newLine >= 0 ? num((reasons[newLine].match(/\+(\d+)/) || [])[1]) : 0;
+      if (oldLine[1]) {
+        score = Math.round(score - newPts + num(oldLine[2]));
+        const kept = `${oldLine[1]} (kept from the scan; the note holds part of the posting)`;
+        if (newLine >= 0) reasons[newLine] = kept; else reasons.splice(Math.min(3, reasons.length), 0, kept);
+      }
+    }
+    const delta = score - stored;
+    if (delta) changes.push({ file: f, company: job.company, title: job.title, stored, updated: score, delta, status: fm('status') });
+    if (!dry) {
+      text = text.replace(/^score: .*$/m, `score: ${score}`);
+      if (/^pay_band: /m.test(text)) text = text.replace(/^pay_band: .*$/m, `pay_band: ${scored.payBand || 'unknown'}`);
+      text = stampWeights(text, fingerprint);
+      const why = `## Why it matched\n${reasons.map((r) => `- ${r}`).join('\n')}\n\n`;
+      text = /^## Why it matched[ \t]*\n/m.test(text) ? text.replace(/^## Why it matched[ \t]*\n[\s\S]*?(?=^## |(?![\s\S]))/m, () => why) : text;
+      if (delta) text = appendUnder(text, 'Status log', `- ${new Date().toISOString().slice(0, 10)} — rescored ${stored} → **${score}** with criteria ${fingerprint} (via cli)`);
+      fs.writeFileSync(file, text);
+    }
+  }
+  changes.sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta));
+  return { total: files.length, considered: seen, alreadyCurrent: skipped, changed: changes.length, changes, fingerprint, full: true };
+}
+
+function appendUnder(text, heading, line) {
+  const re = new RegExp(`(^## ${heading}[ \\t]*\\n)([\\s\\S]*?)(?=^## |(?![\\s\\S]))`, 'm');
+  if (!re.test(text)) return text.trimEnd() + `\n\n## ${heading}\n${line}\n`;
+  return text.replace(re, (all, h, content) => { const body = content.trim(); return `${h}${body ? body + '\n' : ''}${line}\n\n`; });
+}
+
+/** Set or replace the `weights:` frontmatter line, without disturbing anything else. */
+function stampWeights(text, fingerprint) {
+  return /^weights: .*$/m.test(text)
+    ? text.replace(/^weights: .*$/m, `weights: ${fingerprint}`)
+    : text.replace(/^(score: .*)$/m, `$1\nweights: ${fingerprint}`);
+}

package/scraper/resume-sync.mjs

@@ -0,0 +1,224 @@
+// Keep the resume note application drafts read in step with the resume the person actually maintains.
+//
+// Drafts are written from Profile/Resume.md. The person edits their resume somewhere else — a Google Doc, a
+// portfolio page, a .docx — and nothing noticed when the two drifted. The first time it happened on a real
+// vault, an application packet went on quoting "three of five evals in production" after that line had been
+// removed from the resume, and would have contradicted the person's own portfolio if it had been sent.
+//
+// So a sync does two jobs. It rewrites the note from the source, and it reports what changed — including any
+// application packet that still quotes a claim the resume no longer makes. The second is the point.
+//
+// No credentials, no API. A source is a URL anyone can read, or a local file:
+//   - a Google Doc shared as "anyone with the link can view" (fetched through its markdown export)
+//   - any public page, e.g. a portfolio's /resume
+//   - a local .md, .txt, .docx or .pdf — including a Doc downloaded with File > Download
+import fs from 'node:fs';
+import path from 'node:path';
+import { P, VAULT, CONFIG_FILE, HOME_DIR } from './config.mjs';
+import { htmlToText } from './sources.mjs';
+import { extractText } from './resume.mjs';
+
+/** The canonical resume note. Generic on purpose: nothing about it should assume whose resume it is. */
+export const RESUME_NOTE = 'Profile/Resume.md';
+/** Where earlier versions of this project kept it. Read as a fallback, never written. */
+export const LEGACY_RESUME_NOTES = ['Profile/Resume - Design Engineer (Staff).md', 'Profile/Resume - Master.md'];
+
+const today = () => new Date().toISOString().slice(0, 10);
+
+// ---------------- the remembered source ----------------
+
+function readConfig() {
+  try { return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8')); } catch { return {}; }
+}
+export function rememberedSource() {
+  return readConfig().resumeSource || '';
+}
+function rememberSource(source) {
+  fs.mkdirSync(HOME_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify({ ...readConfig(), resumeSource: source }, null, 2));
+}
+
+// ---------------- fetching ----------------
+
+/** A Google Docs editing URL, turned into its markdown export URL. Anything else returns null. */
+export function docExportUrl(url) {
+  const m = String(url).match(/docs\.google\.com\/document\/d\/([A-Za-z0-9_-]+)/);
+  return m ? `https://docs.google.com/document/d/${m[1]}/export?format=md` : null;
+}
+
+async function readSource(source) {
+  if (/^https?:\/\//i.test(source)) {
+    const exportUrl = docExportUrl(source);
+    const res = await fetch(exportUrl || source, {
+      headers: { 'user-agent': 'TekJobs/1.0 (resume sync; a link the user gave)', accept: 'text/markdown,text/plain,text/html' },
+      redirect: 'follow',
+      signal: AbortSignal.timeout(25000),
+    });
+    const body = await res.text();
+    if (exportUrl && (res.status === 401 || res.status === 403 || /accounts\.google\.com/.test(res.url))) {
+      throw Object.assign(new Error([
+        'That Google Doc is private, so it cannot be read without signing in, and this command does not sign in.',
+        'Any one of these works:',
+        '  1. Share the Doc as "Anyone with the link can view", then sync again.',
+        '  2. File > Download > Markdown (.md) or Word (.docx), then: tekjobs resume sync <that file>',
+        '  3. Sync from a public page instead, e.g. your portfolio\'s /resume.',
+      ].join('\n')), { status: 403 });
+    }
+    if (!res.ok) throw Object.assign(new Error(`Fetching ${source} returned HTTP ${res.status}.`), { status: 502 });
+    const isHtml = /text\/html/i.test(res.headers.get('content-type') || '') || /^\s*<!doctype html|<html[\s>]/i.test(body);
+    return { text: isHtml ? pageText(body) : body, kind: exportUrl ? 'google-doc' : isHtml ? 'web-page' : 'url' };
+  }
+  const file = path.resolve(source);
+  if (!fs.existsSync(file)) throw Object.assign(new Error(`No such file: ${file}`), { status: 404 });
+  return { text: await extractText(file), kind: 'file' };
+}
+
+/**
+ * A resume page as text: the <main> element when there is one, without the site's navigation, and with
+ * in-site links reduced to their text. A resume that carries the whole site menu reads as a resume that
+ * changed every time the menu did.
+ */
+function pageText(html) {
+  const main = html.match(/<main[\s>][\s\S]*<\/main>/i);
+  const scoped = (main ? main[0] : html)
+    .replace(/<\s*(nav|header|footer|aside|button|svg|noscript)[\s>][\s\S]*?<\/\s*\1\s*>/gi, '')
+    .replace(/<a [^>]*href="(?!https?:|mailto:)[^"]*"[^>]*>([\s\S]*?)<\/a>/gi, '$1');
+  return htmlToText(scoped);
+}
+
+// ---------------- comparing ----------------
+
+/** Resume lines with markdown and spacing stripped, so the same text in two formats compares equal. */
+function lines(text = '') {
+  return String(text)
+    .replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '')   // frontmatter
+    .split(/\r?\n/)
+    .filter((l) => !/^\s*>/.test(l))                  // banners about the note, not the resume
+    .map((l) => l
+      .replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1')        // links
+      .replace(/^\s*(?:[#>*+-]|\d+\.)+\s*/, '')         // headings, quotes, bullets
+      .replace(/[*_`]/g, '')
+      .replace(/\s+/g, ' ')
+      .trim())
+    .filter((l) => l.length > 2);
+}
+const key = (l) => l.toLowerCase().replace(/[^\p{L}\p{N}%]+/gu, ' ').trim();
+
+const NUMBER_WORD = /^(one|two|three|four|five|six|seven|eight|nine|ten|eleven|twelve|thirteen|fourteen|fifteen|twenty|thirty|fifty|hundred|thousand|million|dozen|half)$/i;
+const FILLER = new Set(['of', 'across', 'the', 'a', 'an', 'and', 'or', 'to', 'in', 'on', 'for', 'with', 'than', 'plus', 'more']);
+const YEAR_OR_DATE = /^(19|20)\d\d$|^\d{1,2}$/;
+
+/**
+ * The checkable claims in a line: each figure or number word with the word it counts. "three of five evals"
+ * gives "three five" and "five evals"; "175 components", "fifteen scheduled". Numbers are what a packet quotes
+ * and what a reader checks, and pairing each with its noun survives rewording around it — "fifteen scheduled
+ * operational pipelines" and "fifteen scheduled pipelines" make the same claim. Dates are not claims.
+ */
+function claims(line) {
+  const words = key(line).split(' ').filter((w) => w && !FILLER.has(w));
+  const out = new Set();
+  words.forEach((w, i) => {
+    const isFigure = /^\d/.test(w) && !YEAR_OR_DATE.test(w);   // starts with a digit: "175", "500k", not "html5" or "css3"
+    if ((isFigure || NUMBER_WORD.test(w)) && words[i + 1] && !YEAR_OR_DATE.test(words[i + 1])) out.add(`${w} ${words[i + 1]}`);
+  });
+  return [...out];
+}
+
+/** The same pairs, for a whole text, so presence can be checked without caring how the sentence was phrased. */
+const claimSet = (text) => new Set(lines(text).flatMap(claims));
+
+// A reworded claim is still the same claim: "fifteen scheduled pipelines" and "15 scheduled pipelines",
+// "175 components" and "a 175-component design system", "twelve packages" and "12 npm packages".
+// So claims are compared on a canonical number plus the stem of the noun, and a claim counts as kept when
+// both appear anywhere in one line of the new resume, not only side by side.
+const WORD_NUM = { one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9, ten: 10, eleven: 11, twelve: 12, thirteen: 13, fourteen: 14, fifteen: 15, twenty: 20, thirty: 30, fifty: 50, hundred: 100, thousand: 1000, million: 1000000, dozen: 12 };
+const canonNum = (w) => (w.toLowerCase() in WORD_NUM ? String(WORD_NUM[w.toLowerCase()]) : w.toLowerCase());
+const stem = (w) => w.toLowerCase().replace(/ies$/, 'y').replace(/(?<=[a-z]{3})s$/, '').slice(0, 8);
+const claimKey = (c) => { const [n, ...rest] = c.split(' '); return `${canonNum(n)} ${stem(rest.join(' '))}`; };
+/** True when some line of `text` carries the claim's number and its noun, however the sentence is built. */
+function stillClaimed(claim, text) {
+  const [n, ...rest] = claim.split(' ');
+  const num = canonNum(n), noun = stem(rest.join(' '));
+  return lines(text).some((l) => {
+    const words = key(l).split(' ').filter(Boolean);
+    return words.some((w) => canonNum(w) === num) && words.some((w) => stem(w) === noun);
+  });
+}
+
+function currentNoteText() {
+  for (const rel of [RESUME_NOTE, ...LEGACY_RESUME_NOTES]) {
+    const file = path.join(VAULT, rel);
+    if (fs.existsSync(file)) return { rel, text: fs.readFileSync(file, 'utf8') };
+  }
+  return { rel: '', text: '' };
+}
+
+/**
+ * Job notes whose Application section still quotes a claim the resume has stopped making. Checked against
+ * the new resume as a whole, so a claim that was only reworded — the figure still there in another line —
+ * does not raise a false alarm.
+ */
+function stalePackets(removedLines, newText) {
+  const kept = claimSet(newText);
+  const gone = [...new Set(removedLines.flatMap(claims))].filter((c) => !kept.has(c) && !stillClaimed(c, newText));
+  if (!gone.length || !fs.existsSync(P.jobs)) return [];
+  const hits = [];
+  for (const f of fs.readdirSync(P.jobs).filter((x) => x.endsWith('.md'))) {
+    const text = fs.readFileSync(path.join(P.jobs, f), 'utf8');
+    const section = (text.match(/^## Application\r?\n([\s\S]*?)(?=^## |(?![\s\S]))/m) || [, ''])[1];
+    if (!section.trim()) continue;
+    const inPacket = new Set(claims(section).map(claimKey));
+    const quoted = gone.filter((c) => inPacket.has(claimKey(c)));
+    if (quoted.length) hits.push({ note: f.replace(/\.md$/, ''), quotes: quoted });
+  }
+  return hits;
+}
+
+/** Exposed for tests: the comparison is the part of this module that must not cry wolf, and must not go quiet. */
+export const _internals = { claims, claimKey, stillClaimed, lines, stalePackets };
+
+// ---------------- the command ----------------
+
+export async function syncResume({ source = '', dry = false } = {}) {
+  const src = source || rememberedSource();
+  if (!src) {
+    throw Object.assign(new Error('No resume source yet. Pass one the first time: tekjobs resume sync <google-doc-url | page-url | file>'), { status: 400 });
+  }
+
+  const { text, kind } = await readSource(src);
+  const body = String(text).replace(/\r\n/g, '\n').trim();
+  if (body.length < 400) {
+    throw Object.assign(new Error(`The resume from ${src} came back nearly empty (${body.length} characters), so nothing was written. If it is a web page, check it renders without JavaScript.`), { status: 422 });
+  }
+
+  const previous = currentNoteText();
+  const before = lines(previous.text);
+  const after = lines(body);
+  const beforeKeys = new Set(before.map(key));
+  const afterKeys = new Set(after.map(key));
+  const removed = before.filter((l) => !afterKeys.has(key(l)));
+  const added = after.filter((l) => !beforeKeys.has(key(l)));
+  const stale = stalePackets(removed, body);
+
+  const note = [
+    '---',
+    'type: resume',
+    'status: current',
+    `source: ${JSON.stringify(src)}`,
+    `source_kind: ${kind}`,
+    `synced: ${today()}`,
+    '---',
+    `> **Synced from the source above on ${today()} by \`tekjobs resume sync\`.** Application drafts read this note. Edit the source, not this note: the next sync replaces it.`,
+    '',
+    body,
+    '',
+  ].join('\n');
+
+  if (!dry) {
+    fs.mkdirSync(path.join(VAULT, 'Profile'), { recursive: true });
+    fs.writeFileSync(path.join(VAULT, RESUME_NOTE), note);
+    if (source) rememberSource(/^https?:\/\//i.test(source) ? source : path.resolve(source));
+  }
+
+  return { source: src, kind, chars: body.length, previous: previous.rel, removed, added, stale, wrote: !dry, note: RESUME_NOTE };
+}