qiksy 1.0.0

package/tools/work-finder/vendor/lib/prompts.mjs

@@ -0,0 +1,217 @@
+/** Prompt builders for the headless Claude agents. */
+
+import { searchStrategyBlock } from './channels.mjs';
+
+const ENGAGEMENT_TEXT = {
+  staff: 'staff employment (in-house position) only',
+  contract: 'B2B contract / vendor / freelance engagement only',
+  both: 'staff employment OR B2B contract / vendor — both are acceptable',
+};
+
+function resumeExcerpt(profile, maxLen = 2500) {
+  const r = (profile?.resume || '').trim();
+  return r.length > maxLen ? r.slice(0, maxLen) + '\n…(truncated)' : r;
+}
+
+/**
+ * @param {object} position
+ * @param {object} profile
+ * @param {string[]} excludeCompanies already found — never returned twice
+ * @param {object} settings
+ * @param {{wave?: number, waves?: number}} [pass] which sweep this is, when the
+ *   search runs to exhaustion: each wave gets a DIFFERENT angle, because asking the
+ *   same question again returns the same answers.
+ */
+/**
+ * Which slice of the freshness range this sweep works.
+ *
+ * The user picks a WINDOW ("0 to 8 days old"), not a cutoff, and the sweeps walk it
+ * newest-first: sweep 1 takes the freshest slice, each next one reaches further back,
+ * and the final sweep opens the whole window as a catch-all. That covers the range
+ * instead of re-reading its first day over and over — and it doubles as the change of
+ * angle a repeat sweep needs to return anything new.
+ */
+function freshSlice(from, to, wave, waves) {
+  if (to <= from) return { from, to };
+  if (wave >= waves) return { from, to }; // last pass sees everything
+  const step = Math.max(1, Math.ceil((to - from) / Math.max(1, waves - 1)));
+  const lo = from + step * (wave - 1);
+  return lo >= to ? { from, to } : { from: lo, to: Math.min(to, lo + step) };
+}
+
+export function searchPrompt(position, profile, excludeCompanies, settings, pass = {}) {
+  const n = settings.resultsPerSearch || 8;
+  const wave = pass.wave || 1;
+  const waves = pass.waves || 1;
+  const fresh = freshSlice(
+    Math.max(0, settings.freshnessFrom ?? 0),
+    Math.max(1, settings.freshnessDays ?? 14),
+    wave,
+    waves,
+  );
+  return `You are a job-search agent. Find companies that are CURRENTLY hiring for the position below. Use WebSearch (and WebFetch to verify pages).
+
+POSITION: ${position.title}
+KEYWORDS / STACK: ${position.keywords || '—'}
+ENGAGEMENT: ${ENGAGEMENT_TEXT[position.engagement] || ENGAGEMENT_TEXT.both}
+CANDIDATE LOCATION: ${profile?.location || 'Ukraine'} — works remotely from there (or B2B contract)
+${settings.searchExtra ? `EXTRA INSTRUCTIONS FROM USER: ${settings.searchExtra}\n` : ''}
+CANDIDATE (for relevance filtering):
+${resumeExcerpt(profile, 1200)}
+
+${searchStrategyBlock(settings, pass.canNarrow)}
+
+GLOBAL COVERAGE RULE: spread findings across regions and sources — companies headquartered in US, UK/EU, DACH, Nordics, Israel, APAC etc. Take AT MOST 2-3 results from any single board or source; the rest must come from other sources. The goal is worldwide reach, not one local board.
+
+RULES:
+- Prefer product / IT companies posting vacancies on their OWN career pages or ATS; when a board led you to a company, dig to the direct company vacancy URL.
+- NEVER construct or guess a vacancy URL. Return only URLs you actually fetched and confirmed to show THIS job (the page contains the job title). If you cannot confirm a direct URL, put the careers page in careers_url and leave vacancy_url null — a wrong link is worse than no link.
+- Verify each opening is real and current (posted / still listed now). Skip expired listings.
+- FRESHNESS WINDOW for this pass: openings posted or updated ${fresh.from === 0 ? `within the last ${fresh.to} days` : `between ${fresh.from} and ${fresh.to} days ago`}. Job boards show posting dates — use them; on career pages without dates, accept only if the source that led you there marks it as within this window. Fill "posted_date" when known. Do NOT return anything outside the window: a later pass covers the older ground.
+- GEOGRAPHY OF REMOTE — critical. "Remote" usually means remote-within-a-country/region. For EVERY vacancy read the location restrictions on the page ("Remote — Worldwide", "Remote (US only)", "EU work permit required", "must be based in…", timezone limits) and classify remote_scope:
+  * "global" — work from anywhere / worldwide, or explicitly open to the candidate's country;
+  * "region" — restricted to a region (EU, EMEA, LATAM, US…) — note which;
+  * "country" — remote but within one country;
+  * "none" — onsite/hybrid.
+  SKIP vacancies where the candidate in ${profile?.location || 'Ukraine'} is clearly NOT eligible (e.g. "US only" for a candidate in Europe). Prefer "global" ones; "region" is ok when the candidate's location fits or a B2B contract plausibly works.
+- Skip pure staffing agencies and lead-generation spam.
+- Skip these companies (already found earlier): ${excludeCompanies.length ? excludeCompanies.join(', ') : 'none'}.
+- Find AT LEAST ${n} distinct openings at distinct companies — more is better. There is no upper limit: return every match you can confirm in this pass.
+- SCORE THE FIT: for every vacancy set "match" to an INTEGER 0-100 — how well THIS role fits the candidate above (stack & seniority overlap, remote eligibility from ${profile?.location || 'Ukraine'}, engagement type). Be honest and discriminating: reserve 90+ for a strong direct match, 60-75 for a plausible partial fit, below 50 for a stretch. The "notes" field should justify the number in one line.
+- WORK FAST but do not stop early: broad WebSearch queries first, then WebFetch the promising pages. Streaming a confirmed find costs nothing extra, so stream as you go.
+- TIME BUDGET: up to ~12 minutes for this pass. Stop when you genuinely run out of NEW companies, not when you reach a number.
+${wave > 1 ? `- THIS IS SWEEP #${wave}. Everything the earlier sweeps found is in the exclusion list above and must not come back. Asking the same question again returns the same answers, so change the ANGLE: different search phrasings and role synonyms, different ATS hosts, different regions and countries, smaller and less-known companies, older-but-still-open postings, adjacent titles the candidate also fits. If a whole angle turns up nothing new, say so and finish the pass — an honest empty sweep ends the search cleanly.` : ''}
+
+PROGRESS STREAMING: the user watches results arrive live. As soon as you have CONFIRMED one vacancy (page fetched, fresh, geography checked), immediately print a single line:
+VACANCY: {"company":...}   ← one-line JSON, exact same fields as the array items below
+…then continue searching. Stream every confirmed finding this way.
+
+FINAL OUTPUT: at the end return ONLY a JSON array with ALL findings (including the streamed ones), no prose, no markdown fences:
+[{"company":"","website":"","careers_url":"","vacancy_title":"","vacancy_url":"","location":"","remote":true,"remote_scope":"global|region|country|none","eligibility_note":"one short line: can the candidate apply from ${profile?.location || 'Ukraine'}, what limits apply","engagement":"staff|contract|both|unknown","apply_method":"form|email|linkedin|unknown","apply_email":null,"salary":null,"posted_date":"YYYY-MM-DD or null","source":"where you found it","match":85,"notes":"1-2 sentences: why it fits, key requirements"}]`;
+}
+
+export function coverLetterPrompt(vacancy, profile) {
+  return `You are helping a candidate apply for a job. Write a concise, specific cover letter (150-250 words) for this vacancy. If a vacancy URL is given, use WebFetch to read the actual job description first and mirror its language (English unless the posting is clearly in another language).
+
+VACANCY:
+- Company: ${vacancy.company}
+- Title: ${vacancy.vacancy_title}
+- URL: ${vacancy.vacancy_url || vacancy.careers_url || '—'}
+- Notes: ${vacancy.notes || '—'}
+
+CANDIDATE:
+${resumeExcerpt(profile)}
+
+Rules: no generic fluff ("I am excited to apply…" openers), lead with the strongest overlap between the candidate and THIS role, mention 2-3 concrete matching achievements/skills, close with availability (remote, staff or B2B contract both possible). Sign as ${profile?.name || 'the candidate'}, ${profile?.email || ''}.
+STRICT HONESTY: use ONLY facts present in the resume above. Never invent projects, employers, metrics, or claims like "I use your product daily". If the resume lacks a requirement, do not pretend otherwise — emphasise adjacent real experience instead.
+
+OUTPUT: return ONLY the cover letter text, nothing else.`;
+}
+
+export function autoApplyPrompt(vacancy, profile, coverLetter, autoSubmit) {
+  return `You are a browser automation agent applying to a job on behalf of the candidate (with their explicit consent). Use the playwright MCP tools. The browser is already running; open pages in a NEW tab (browser_tabs → new) and do not touch the user's other tabs.
+
+TASK:
+1. Open: ${vacancy.vacancy_url || vacancy.careers_url}
+2. Find the application form for the vacancy "${vacancy.vacancy_title}" (follow an "Apply" button if needed).
+3. Fill the form:
+   - Name: ${profile?.name || ''}
+   - Email: ${profile?.email || ''}
+   - LinkedIn: ${profile?.linkedin || ''}
+   - Location: ${profile?.location || 'Ukraine'} (remote)
+   - Cover letter / message field: use the COVER LETTER below.
+   - If a CV file upload is REQUIRED and no file is available, note it in the report instead of failing.
+   - Any other required questions: answer truthfully and briefly based on the CANDIDATE RESUME below; if an answer cannot be derived from the resume, leave it and report.
+4. ${autoSubmit
+    ? 'SUBMIT the application, then take a screenshot of the confirmation.'
+    : 'Do NOT press the final submit button. Fill everything, take a screenshot of the completed form, and report that it is ready for manual review.'}
+
+COVER LETTER:
+${coverLetter || '(generate a short one from the resume)'}
+
+CANDIDATE RESUME:
+${resumeExcerpt(profile)}
+
+OUTPUT: return ONLY JSON: {"status":"submitted|ready_for_review|no_form_found|failed","details":"what was done, what fields were filled, what remains","form_url":"url of the form page"}`;
+}
+
+export function leadsSearchPrompt(profiles, excludeCompanies, settings) {
+  const candidates = profiles
+    .map(p => `— ${p.name} (based in ${p.location || 'Europe'}): ${resumeExcerpt(p, 700)}`)
+    .join('\n\n');
+  const month = new Date().toLocaleString('en', { month: 'long', year: 'numeric' });
+  return `You are a lead-generation agent for two software engineers seeking work (staff or B2B contract). Find PRODUCT companies that recently raised funding — a strong signal they are hiring or will hire soon, even with NO public job postings.
+
+TASK:
+1. WebSearch for product/tech companies that announced a funding round (pre-seed / seed / Series A / Series B) within the LAST 60 DAYS (today: ${month}). Sources: TechCrunch, tech.eu, EU-Startups, SiliconCanals, Crunchbase news, YC batch announcements, VC portfolio news pages.
+2. Keep companies whose product/stack plausibly needs at least one candidate below: AI assistants / LLM integration, React/TypeScript web products, Python backends.
+3. For each company find an outreach contact: founder / CTO / VP Engineering — name plus a public email, LinkedIn URL, or the site's contact/careers form URL (WebFetch the company site, check About/Team pages).
+4. Also note hiring evidence if any exists (ATS page, careers page, "we're hiring" mentions).
+5. Skip these companies (already known): ${excludeCompanies.length ? excludeCompanies.join(', ') : 'none'}.
+${settings.searchExtra ? `6. EXTRA USER INSTRUCTIONS: ${settings.searchExtra}\n` : ''}
+CANDIDATES:
+${candidates}
+
+OUTPUT: return ONLY a JSON array, 6-10 items, no prose:
+[{"company":"","website":"","signal":"Raised $X seed, May 2026, led by <investor>","source_url":"","why_fit":"1-2 sentences: what they build and why the candidate fits","fits_profile":"exact candidate name from above","contact_name":"","contact_role":"","contact_channel":"email|linkedin|form|unknown","contact_value":"email address / linkedin url / form url","hiring_evidence":"careers or ATS url, or null"}]`;
+}
+
+export function pitchPrompt(lead, profile) {
+  return `Write a cold outreach email (110-170 words) from a software engineer to a company that just raised funding. If useful, WebFetch the company site to reference their product accurately.
+
+COMPANY: ${lead.company} — ${lead.website || ''}
+SIGNAL: ${lead.signal || 'recent funding round'}
+WHAT THEY BUILD / WHY FIT: ${lead.why_fit || '—'}
+ADDRESSEE: ${lead.contact_name || 'founder/CTO'} (${lead.contact_role || ''})
+
+SENDER (the candidate):
+${resumeExcerpt(profile)}
+
+Rules:
+- Subject line first ("Subject: …"), then the email body.
+- Hook: congratulate briefly on the round (one clause, no flattery), then one sentence on the concrete value the candidate brings to THEIR product right now.
+- 2-3 factual proof points from the resume. STRICT HONESTY: only facts present in the resume, never invent.
+- Offer: available as staff hire or B2B contractor, remote from ${profile?.location || 'Europe'}; suggest a short intro call.
+- Sign: ${profile?.name || ''}, ${profile?.email || ''}, ${profile?.linkedin || ''}.
+- Language: English unless their site is clearly in another language.
+
+OUTPUT: only the subject + email text, nothing else.`;
+}
+
+export function importResumePrompt(rawText) {
+  return `Below is raw text scraped from a LinkedIn profile (it contains UI noise: menus, footers, ads). Extract the person's professional resume and rewrite it as clean English markdown with sections: header (name, headline, location, contacts), Summary, Experience (company, role, dates, bullets), Projects, Certifications, Skills, Education. Keep every real fact, drop all UI noise. Return ONLY the markdown.
+
+RAW PROFILE TEXT:
+${rawText.slice(0, 18_000)}`;
+}
+
+/** «Tell about yourself» → a structured professional profile. Hard-scoped to the
+ *  profession: never touches personal/sensitive data, ignores off-topic, and lists
+ *  professional GAPS to make the résumé (and therefore the job search) stronger. */
+export function buildFromStoryPrompt(story, lang = 'en') {
+  const langName = lang === 'uk' ? 'Ukrainian' : lang === 'ru' ? 'Russian' : 'English';
+  return `You are a professional résumé assistant inside a job-search tool. A person just described themselves in their own words (possibly voice-transcribed — informal, out of order, with filler). Turn it into a STRUCTURED PROFESSIONAL profile.
+
+STRICT SCOPE — you build a professional résumé, nothing else:
+- Use ONLY professional information: role/title, seniority, years of experience, tech stack & skills, companies, projects, responsibilities, achievements, education/certifications, languages spoken (professional), location for remote eligibility.
+- NEVER include or ask for personal/sensitive data: age, date of birth, marital status, children, gender, religion, politics, health, ethnicity, photo, salary. If the person mentioned any of it, silently omit it.
+- Ignore anything off-topic (weather, small talk, jokes). Do NOT answer questions or chat — only extract résumé facts.
+
+GAPS — help make the profile complete for strong job matching. In "gaps", list 3–6 SHORT, SPECIFIC, professional items that are missing or vague and would improve matching, e.g. "No years of experience stated", "No company names for your roles", "Backend stack unclear — which DB / framework?", "No seniority level (Senior / Middle?)", "No notable projects or achievements". Professional only — NEVER suggest asking for personal info.
+
+Write "headline", "summary" and the experience "bullets" in ${langName}. Keep skill names in their common form (React, Node.js, PostgreSQL…).
+
+Return ONLY valid JSON — no prose, no markdown fences — in exactly this shape:
+{
+  "name": "", "location": "", "email": "", "linkedin": "",
+  "headline": "", "summary": "",
+  "skills": ["React", "TypeScript"],
+  "experience": [{ "role": "", "company": "", "dates": "", "bullets": ["", ""] }],
+  "education": [{ "degree": "", "school": "", "dates": "" }],
+  "gaps": ["", ""]
+}
+Leave a field as "" or [] when the person didn't provide it (and add the important ones to "gaps").
+
+PERSON'S DESCRIPTION:
+${String(story).slice(0, 8000)}`;
+}

package/tools/work-finder/vendor/lib/spawn-claude.mjs

@@ -0,0 +1,44 @@
+/**
+ * Start the `claude` CLI — on any operating system.
+ *
+ * On macOS and Linux `claude` on PATH is a real executable and Node's own spawn finds
+ * it. ON WINDOWS IT IS NOT: npm installs a `claude.cmd` shim, and Node cannot execute
+ * a .cmd without a shell — recent versions refuse outright (the fix for CVE-2024-27980).
+ * So every call landed on ENOENT and the panel announced "Claude Code is not installed"
+ * on a machine where it was installed and working perfectly. The probe, the sign-in and
+ * the agent runs all went through this one door, so on Windows nothing worked at all.
+ *
+ * `shell: true` would make the error go away and open a hole instead: the agent passes
+ * the user's OWN TEXT in argv — a resume, a job description, an MCP config as JSON —
+ * and through cmd.exe every `&`, `|`, `^` and quote in it becomes a shell metacharacter.
+ * cross-spawn is the standard answer to exactly this (npm itself runs on it): it
+ * resolves the shim and escapes arguments for cmd.exe properly.
+ *
+ * Imported LAZILY, with a fallback, so the backends keep the "no dependencies"
+ * property they were written for: run from this monorepo they get cross-spawn, run
+ * standalone on macOS or Linux they fall back to Node's spawn — which is exactly what
+ * they used before this file existed.
+ */
+
+import { spawn as nodeSpawn } from 'node:child_process';
+
+let impl = null;
+try {
+  impl = (await import('cross-spawn')).default;
+} catch {
+  // Only Windows actually needs it; saying so anywhere else would be noise.
+  if (process.platform === 'win32') {
+    console.warn(
+      '[claude] cross-spawn is missing, and on Windows the CLI cannot be started without it.\n' +
+        '         Run `npm install` in the qiksy-studio root, then start this server again.',
+    );
+  }
+}
+
+/**
+ * @param {string[]} args argv for the CLI
+ * @param {import('node:child_process').SpawnOptions} [opts]
+ */
+export function spawnClaude(args, opts = {}) {
+  return (impl ?? nodeSpawn)('claude', args, opts);
+}

package/tools/work-finder/vendor/lib/store.mjs

@@ -0,0 +1,125 @@
+/** JSON file store: data/db.json. Zero deps, sync IO (single-user tool). */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+/* Where runtime state lives (db, LinkedIn dumps, the CDP profile). Defaults to the
+   package's own data/ for dev, but the shipped launcher points WF_DATA_DIR at a stable
+   user folder (~/.qiksy-work-finder) — a published package must NOT write into node_modules
+   / the npx cache, or the user loses their candidates between runs. */
+export const DATA_DIR = process.env.WF_DATA_DIR ? resolve(process.env.WF_DATA_DIR) : resolve(ROOT, 'data');
+const DB_PATH = process.env.WF_DB ? resolve(process.env.WF_DB) : resolve(DATA_DIR, 'db.json');
+
+export const uid = () => Date.now().toString(36) + Math.random().toString(36).slice(2, 7);
+
+// A fresh install starts EMPTY — no seeded candidate (owner decision 2026-07-19:
+// every flow begins from zero — after connecting the key the user creates their
+// own first candidate; the frontend's zero-profile onboarding guides that step).
+function defaults() {
+  return {
+    settings: {
+      model: 'sonnet',
+      autoSubmit: false,
+      searchViaBrowser: false,
+      searchExtra: '',
+      /* Per SWEEP, and a FLOOR, not a ceiling — the search runs sweep after sweep
+         until one turns up nothing new (server.mjs startSearch). It used to be a
+         hard cap of 8, which is why "React developer, worldwide" came back with
+         four: our own prompt told the agent to stop. */
+      resultsPerSearch: 20,
+      /* A WINDOW, not a cutoff: [freshnessFrom … freshnessDays] days old. The sweeps
+         walk it newest-first so the range is covered instead of its first day being
+         re-read every pass. Three days was aggressive enough to hide most of the
+         market; two weeks is still "current" and leaves something to find. */
+      freshnessFrom: 0,
+      freshnessDays: 14,
+      /* How many sweeps at most. Unbounded would spend the user's whole Claude
+         quota in one night; two barren sweeps in a row also end it early. */
+      maxSweeps: 6,
+      /* How long the search history is kept, in days. The database grows with every
+         run and nothing ever removed anything, so it only went one way. Purging is
+         deliberately CONSERVATIVE: a run's record and its UNTOUCHED findings go, but
+         anything the user acted on (wrote a letter, applied, changed the status)
+         stays forever — deleting the record of an application you sent would be
+         losing the user's own work, not tidying up. */
+      historyDays: 30,
+      excludeBoards: false, // true = только прямые вакансии компаний/ATS, без джоб-бордов
+      plan: 'free', // ручной план: только free/dev. Платные (start/pro) — по лицензии.
+      license: '', // ключ лицензии (wf_…); пусто = бесплатный тариф
+      licenseInfo: null, // кэш последней проверки: {plan, active, paidUntil, trial, checkedAt}
+    },
+    // usage — только информативный лог стоимости токенов юзера (его ключ). Кредитов нет.
+    usage: { totalCostUsd: 0, log: [] },
+    profiles: [],
+    positions: [],
+    vacancies: [],
+    leads: [],
+    searches: [], // история запусков поиска: {id, at, titles, profileIds, vacancyIds, added}
+  };
+}
+
+/**
+ * Drop search history older than `historyDays`, and with it the findings nobody ever
+ * touched. Runs on load, so it costs nothing and needs no scheduler.
+ *
+ * "Untouched" means status still `new`, no cover letter, no apply result. Everything
+ * else is the user's own work and is kept regardless of age — the history window is
+ * about our noise, not about their applications.
+ *
+ * @returns {{runs:number, vacancies:number}} what was removed
+ */
+export function purgeHistory(db) {
+  const days = Math.max(1, db.settings?.historyDays ?? 30);
+  const cutoff = Date.now() - days * 86_400_000;
+  const oldRuns = (db.searches || []).filter(r => (r.at || 0) < cutoff);
+  if (!oldRuns.length) return { runs: 0, vacancies: 0 };
+
+  const doomed = new Set(oldRuns.flatMap(r => r.vacancyIds || []));
+  const keep = v =>
+    !doomed.has(v.id) ||
+    v.status !== 'new' ||
+    v.coverLetter ||
+    v.applyResult;
+
+  const before = db.vacancies.length;
+  db.vacancies = db.vacancies.filter(keep);
+  db.searches = (db.searches || []).filter(r => (r.at || 0) >= cutoff);
+  return { runs: oldRuns.length, vacancies: before - db.vacancies.length };
+}
+
+export function load() {
+  if (!existsSync(DB_PATH)) {
+    const db = defaults();
+    save(db);
+    return db;
+  }
+  const db = JSON.parse(readFileSync(DB_PATH, 'utf8'));
+  // migrate: fill keys added after the db was first created
+  db.settings = { model: 'sonnet', autoSubmit: false, searchViaBrowser: false, searchExtra: '', excludeBoards: false, ...defaults().settings, ...db.settings };
+  /* Raise the two limiters for anyone still on the OLD defaults — they were ours,
+     not the user's choice, and they are the reason an exhaustive search returned a
+     handful. A value the user actually picked is left exactly as it is. */
+  if (db.settings.resultsPerSearch === 8) db.settings.resultsPerSearch = 20;
+  if (db.settings.freshnessDays === 3) db.settings.freshnessDays = 14;
+  db.settings.maxSweeps ??= 6;
+  db.settings.freshnessFrom ??= 0;
+  db.settings.historyDays ??= 30;
+  purgeHistory(db);
+  db.positions = db.positions.map(p => ({ selected: true, ...p }));
+  db.leads ||= [];
+  db.searches ||= [];
+  db.settings.plan ||= 'dev'; // существующая (наша) база — без лимитов
+  db.settings.license ??= '';
+  db.settings.licenseInfo ??= null;
+  // сбрасываем наследие кредитов/кошелька, если осталось от старой базы
+  delete db.settings.markup;
+  delete db.wallet;
+  db.usage = { totalCostUsd: db.usage?.totalCostUsd || 0, log: db.usage?.log || [] };
+  return db;
+}
+
+export function save(db) {
+  mkdirSync(dirname(DB_PATH), { recursive: true });
+  writeFileSync(DB_PATH, JSON.stringify(db, null, 2), 'utf8');
+}

package/tools/work-finder/vendor/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "qiksy-work-finder",
+  "version": "1.0.0",
+  "description": "Qiksy Work Finder — your local hiring engine. Claude agents sweep the whole job market, match roles to your profile and draft the letters. Runs on your own Claude; nothing leaves your machine.",
+  "type": "module",
+  "bin": {
+    "qiksy-work-finder": "bin/qiksy-work-finder.mjs"
+  },
+  "scripts": {
+    "start": "node bin/qiksy-work-finder.mjs",
+    "serve": "node server.mjs",
+    "browser": "node scripts/launch-browser.mjs",
+    "extract": "node scripts/extract-linkedin.mjs"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "scripts",
+    "public",
+    "server.mjs",
+    "README.md"
+  ],
+  "keywords": [
+    "qiksy",
+    "work-finder",
+    "job-search",
+    "claude",
+    "ai-agents"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "cross-spawn": "^7.0.6"
+  },
+  "license": "UNLICENSED",
+  "homepage": "https://qiksy.app/work-finder/",
+  "publishConfig": {
+    "access": "public"
+  }
+}