whoelse 0.1.0__tar.gz

whoelse-0.1.0/.github/PUBLISH.md

@@ -0,0 +1,23 @@
+# Publishing checklist (author only)
+
+```bash
+# 1. repository
+gh repo create beskvladimir-create/whoelse --public --source=. --push \
+  --description "Who else is working on what you're working on? An MCP server that finds them, says what you could build together, and drafts the first message. Papers, code, datasets, models. Local. Free."
+gh repo edit beskvladimir-create/whoelse --add-topic mcp --add-topic mcp-server --add-topic research --add-topic collaboration \
+  --add-topic openalex --add-topic arxiv --add-topic huggingface --add-topic claude --add-topic cursor --add-topic codex --add-topic ai-agents
+
+# 2. the author's own card (so the first user of connected mode is the author)
+#    put .well-known/whoelse.json at https://vladimir.besk.tech/.well-known/whoelse.json
+
+# 3. first live run, then paste 3 real lines of output into README under "What you get"
+WHOELSE_MAILTO=vladimir@besk.tech python -m whoelse.scripts.first_run "Vladimir Beskorovainyi" --orcid 0009-0004-7005-6242
+
+# 4. PyPI (optional, after the run)
+python -m build && twine upload dist/*
+
+# 5. registries: submit to modelcontextprotocol/servers (community list), Smithery, mcp.so, PulseMCP, Glama
+```
+
+Launch post (one paragraph, no hype): what the pain is, what the tool did on the author's own name
+(N people, M reachable, first replies), the install line, the card.

whoelse-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,38 @@
+name: release
+# One tag publishes everywhere: PyPI (trusted publishing, no token) and the official MCP Registry (GitHub OIDC).
+# One-time setup on pypi.org: Your projects -> Publishing -> add a pending publisher for project "whoelse",
+# owner beskvladimir-create, repository whoelse, workflow release.yml, environment pypi.
+on:
+  push:
+    tags: ["v*"]
+jobs:
+  pypi:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install build && python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1
+  registry:
+    needs: pypi
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install mcp-publisher
+        run: |
+          curl -L "https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher
+      - name: Version from the tag
+        run: |
+          V=${GITHUB_REF#refs/tags/v}
+          jq --arg v "$V" '.version = $v | .packages[0].version = $v' server.json > s.tmp && mv s.tmp server.json
+      - run: ./mcp-publisher login github-oidc
+      - run: ./mcp-publisher publish

whoelse-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,15 @@
+name: tests
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.10", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: pip install -e ".[dev]"
+      - run: pytest -q

whoelse-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+dist/
+*.egg-info/
+.venv/

whoelse-0.1.0/.well-known/whoelse.json

@@ -0,0 +1,21 @@
+{
+  "name": "Vladimir Beskorovainyi",
+  "working_on": [
+    "text-to-SQL on open-weight models",
+    "classification of citizen appeals at national scale",
+    "machine transcription of historical archives"
+  ],
+  "open_to": [
+    "co-author",
+    "joint benchmark",
+    "cross-replication",
+    "talk together"
+  ],
+  "contact": "vladimir@besk.tech",
+  "languages": [
+    "en",
+    "ru"
+  ],
+  "updated": "2026-11-07",
+  "spec": "https://github.com/beskvladimir-create/whoelse#the-card"
+}

whoelse-0.1.0/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+## 0.1.0 — 2026-11-07
+
+First release.
+
+- Profile from OpenAlex, arXiv, GitHub, Hugging Face, ORCID; namesakes are shown, never guessed.
+- Discovery across papers (OpenAlex keywords and topics, arXiv preprints), code (GitHub) and models/datasets (Hugging Face); quantisation repacks filtered.
+- Ranking with IDF-damped keywords so field-wide terms cannot carry a match.
+- Identity guards: self-exclusion by ids, name merges need a second signal, organisations dropped.
+- Reach: ORCID public contacts, GitHub profile, GitHub user search by full name (unique hit confirmed by repo subject), whoelse card at /.well-known/whoelse.json.
+- joint_work_brief ranks formats by what each side actually has; draft_outreach gives facts and structure, never sends.
+- Peers: add_peer, whats_new_from_peers, with concrete ways to support; no automated stars or follows.
+- find_duplicates / propose_merge: what already exists for an idea, who won, what nobody has; a merge plan with one issue per author.
+  Relevance on job words only; synonyms; search totals and "at least" when capped; four honest verdicts (field / won / cluster / parts exist).
+  Merge limits per GitHub's acceptable use: 3-15 repositories, 10 issues a day, ledger, no forks/organisations/winners/own repos,
+  approval bound to the exact texts shown (plan_id), rate limit stops the run.
+- plugin/: Claude Code plugin with a dont-build-it-alone skill; the same text serves as rules for Cursor, Codex and other MCP clients.
+- publish_request / start_joint_work / whoelse-watch: an open registry of requests, a workspace with a third of the work done, a watcher that starts joint work on a mutual match.
+- 70 offline tests on recorded fixtures; one-command first run.

whoelse-0.1.0/DECISIONS.md

@@ -0,0 +1,151 @@
+# Decisions log
+
+Kept so the reasoning survives the chat that produced it.
+
+## 2026-11-07, v0.1.0
+
+**Why this exists.** Research into "Код популярности" showed the honest engine of recognition is third-party mentions born from joint work, not self-publishing. Joint work needs the right people. Nobody with overlapping work knows each other. That is the pain; whoelse is the lookup.
+
+**What exists already (checked 2026-11-07).**
+Sites: ResearcherCollab (~1.6k people, collab calls, AI matching in PRO), ResearchConnectX, ResearcherNet (Kolkata, ~650 people, institution sales), Collaboratium, Researchmate, CheckMyManuscript collaborator finder. All stop at "here is a person"; none proposes the joint work, none measures reach, none leaves academia.
+MCPs: paper search (paper-search-mcp, arxiv-mcp-server, OpenArx), author profiles (OpenAlex MCP, ORCID MCP), AuthorProfileMCP (co-authors you already have, 1 star), sales people-search (Sixtyfour, Apollo). None does "with whom should I work next, and on what".
+
+**Name.** `whoelse`: a question everyone asks. GitHub checked: `coauthor` taken (280 stars, other project, and too narrow); `kindred` noisy; `whoelse` only a 2-star unrelated repo.
+
+**Shape.** MCP server, not a site: spreads through GitHub and MCP registries, works inside an agent that already knows the user, no cold-start registry, data stays local. First user is the author.
+
+**Sources and rules.**
+- OpenAlex: CC0 metadata; keyword ids (`keywords.id`) are far sharper than topics (a text-to-SQL paper lands in topic "Topic Modeling"). API key optional but recommended (shared per-IP budget without it).
+- arXiv: CC0 descriptive metadata. Submitter emails are behind login, monitored, and forbidden for unsolicited contact. Never used. `arxiv:comment` carries the author's own GitHub/HF links, used to join papers to code.
+- ORCID: public API, keyless. Only `visibility: public` emails. Needs `Accept: application/vnd.orcid+json`; XML fallback parser included.
+- GitHub: REST, token optional. Acceptable Use names "automated starring or following" as rank abuse: whoelse never stars/follows.
+- Hugging Face: keyless. Quantisations/repacks (`base_model:quantized:`, gguf/awq/gptq...) are not the author's work and are filtered.
+- Platform rules checked earlier: X (OAuth is not consent for automated actions), LinkedIn (bots/inauthentic engagement banned), Meta (high-frequency account creation banned). Hence: one message, one person, sent by the user.
+
+**Namesakes.** OpenAlex returned three "Vladimir Beskorovainyi" (Kharkiv, Volgograd, MIPT). Guessing by works_count picks the wrong person. whoelse refuses to guess and asks for ORCID/affiliation.
+
+**Connected mode.** `/.well-known/whoelse.json` on the person's own site. No registry: the web is the directory. Card bonus in ranking (+0.2).
+
+**Not built yet.** Joint proposal to both sides when both have cards (needs an inbox convention); per-source rate budgeting UI; Semantic Scholar as a second paper source; a `reach` index (what search/LLMs answer for the user's name) — belongs to the larger product, not this tool.
+
+**Author.** Vladimir Beskorovainyi, sole author of all commits.
+
+## 2026-11-07, review round
+
+Independent review found 25 items; 20 fixed, 2 rejected as non-bugs, 3 deferred. Live measurements on the author's own topics drove three design changes:
+
+- **Reach is the bottleneck, not discovery.** Of 60 ORCID records behind the top text-to-SQL papers, 4 had a public email and 6 any URL. Of 60 fresh arXiv papers, 7 linked GitHub. So: a third channel, GitHub user search by full name, accepted only on a unique hit confirmed by repository subject (3 of 9 real names resolved; common names return 18–142 namesakes and are skipped).
+- **Generic terms must not carry a match.** "large language models" was shared by nearly everyone in the pool. Keywords are now IDF-weighted over the candidate pool, with a hard-coded generic set damped to 8%.
+- **Identity is guarded, not guessed.** Self-exclusion by ids, not name only; merge of records requires a second signal; organisations are detected on GitHub (type) and Hugging Face (overview) and dropped; an ORCID the user supplies is never stamped onto a namesake; CJK and accented names survive slug/norm.
+
+Robustness: any non-JSON 200 (SPA fallback pages at /.well-known/whoelse.json) is a SourceError; one candidate's broken site cannot take the result down; Retry-After dates parse; arXiv rate-limit text does not crash; per-host concurrency caps; tool errors reach the model as text (ToolError).
+
+Deferred: proposal to both card holders at once; PyPI release; Semantic Scholar as a second index.
+
+## 2026-11-07, verification round
+
+Second independent pass (verifying the fixes) found one serious regression I had introduced: arXiv coauthors were keyed by the paper's GitHub link and collapsed into one person. Fixed: the link stays on the paper; a person merges only on a second signal. Also fixed: outreach now cites the overlapping work, not the newest; affiliation match is token-based (no "MIT" ⊂ "Smith College"); same paper is a merge signal; a full name the person typed into their own GitHub/HF profile is a merge signal except for common family names; Hugging Face profile is a reach channel; card `open_to` lifts matching formats (full paper still after a smaller step); user's namesakes are not dropped as "me"; by-name GitHub lookups capped at 8 without a token; 403+Retry-After retried; semaphores per event loop; headline grammar; namesake flag in lines. 40 tests.
+
+## 2026-11-08, connecting strangers
+
+Vladimir's correction: finding people is not the product; two strangers ending up in one piece of work, fast, is. Knowing each other is a side effect. So: `start_joint_work` (a repository with a third of the work done, both names on it), `publish_request` (an open registry of what people want to build; one JSON per person in a public GitHub repo; no server), `whoelse-watch` (reads the registry, matches, creates the repository, invites, emails both; the user only has to not remove the tool). The honest waiting text keeps people in the queue: "37 are waiting, none on your topic yet; when one joins the work starts by itself and a link goes to you".
+
+Two review rounds on this layer found and fixed: registry files are hostile input (strict schema; control and invisible characters stripped; names with markup rejected); impersonation by file (verification against the GitHub profile; CI requires ids.github == PR author AND that an existing file belongs to the author; workflow runs from base via pull_request_target); what verification cannot prove (that the account is the named researcher), answered by creating the repository private and publishing only after "in"; two watchers creating two repositories (one creator per pair by sorted name; repo name from the pair and the matched keyword, with a hash, never from either side's topic text); overwriting a collaborator's pushes (never write into an existing repo; check .whoelse.json sides); registry read from a 72-hour cache (tree uncached; files by blob sha through the git/blobs API, since raw.githubusercontent does not serve blob shas); SMTP sender forgery (no From → inbox only); state corruption and dry runs starting clocks. 65 tests, the registry CI script is executed in the test suite.
+
+Known limit, stated in README: display-name verification is weak by itself; privacy-until-"in" is the real guard.
+
+## 2026-11-08, before you build it
+
+Vladimir's observation: open source has twenty repositories for every idea, each with ten stars,
+each author alone and wanting the same thing: a response. And agents happily build the 21st.
+So: `find_duplicates` (GitHub search on the idea; keep what is actually the same thing by token
+similarity; order by stars; feature matrix from a fixed vocabulary of feature words, so repository
+descriptions can label but never speak; verdict first) and `propose_merge` (base = the living
+leader, pushed within 90 days with the most stars, so its stars and users carry over; what each
+repository brings is its `only_here` features; one issue per author in their own repository).
+
+Live check on "sync Claude Code sessions across machines": 233 repositories, leader
+tawanorg/claude-sync (320 stars, Go, R2 + end-to-end encryption), ~40 at 2–13 stars with disjoint
+backends (Drive, SSH, Syncthing, Tailscale, Obsidian, git vault, LAN). Early mistakes fixed: queries
+from stop-word-stripped phrases were too weak (now product names and distinctive tokens); cluster
+ordered by similarity put 2-star repos above the leader (now stars); base chosen by recency picked a
+fresh fork over the leader (now living leader); default `max_stars=200` excluded the leader (now
+none).
+
+GitHub's Acceptable Use Policies (read 2026-11-08) prohibit "automated excessive bulk activity",
+"unsolicited advertising or solicitation" and "excessive bulk content in issues". The limits are
+code, not advice: 3–15 living repositories per proposal, 10 issues a day, 3 s pacing, a ledger so
+no repository is asked twice, archived and issues-disabled repositories skipped, the plan inline or
+at a URL the user owns (no placeholder links in anything sent), opened only on the user's explicit
+yes from the user's own account. 74 tests.
+
+Independent review of the layer (same day) found the engine confidently wrong on ordinary inputs:
+product-name mentions counted as overlap ("a Claude Code plugin to back up sessions" → claude-mem,
+114k stars, "already won"); core query words picked by length ("closed-contour" over "nl2sql" → "this
+is new" for the most crowded field on GitHub); capped, star-sorted counts presented as medians; a
+failed search reported as novelty; `max_stars` hiding the leader. On the merge side: no cluster
+bound, a placeholder link in every public issue, the user's own and 3k-star repositories asked,
+approval not bound to the texts shown. All fixed; the fixes are in the tests. Three rules came out
+of it: relevance is measured on job words only, with all of them required for a short idea; a
+cluster is reported with its search total and "at least" when capped; an empty cluster next to a
+related field says "the parts exist", never "new". Claude Code plugin added (`plugin/`) so the check
+runs before the agent writes the first line.
+
+## 2026-11-08, analogues checked again
+
+GitHub topic `idea-validation` (8 repositories) and web search: `mnemox-ai/idea-reality-mcp` (created
+2026-02-24, 830 stars, maintenance mode since 2026-08) scores an idea against GitHub, HN, npm, PyPI,
+Stack Overflow and lists similar repositories with pivot hints; `Smartulf123/check-before-you-build`
+(2026-10, 0 stars) is an agent skill that writes "what exists, where the gap is". Neither builds a
+feature matrix, proposes a merge to the authors, or finds the people. Nearest for people:
+ResearcherCollab, CollabFinder (sites with manual profiles), openalex-research-mcp (co-authorship
+data). The section "Before you build it" was renamed "Don't build it alone" to stop sharing a name
+with a stranger's project and to say what is different: whoelse starts where idea checkers stop.
+Searched in English only, GitHub and the open web; closed products and other languages not covered.
+
+## 2026-11-08, first live run on the author's profile (reported from his machine)
+
+The list was dominated by one lab (Emory) that shared a single OpenAlex topic with the author,
+"Topic Modeling", a bucket that holds half of NLP. Two causes: the pool was seeded with 100 works
+from each of the five top topics, bucket included; and topics were scored without document
+frequency, so a bucket counted as much as a specific topic, with recency (up to 0.2) added on top.
+Fixes, mirrored from what keywords already had: topic document frequency over the pool and damping
+of the known bucket topics; the pool is seeded from the author's specific topics only (two of
+them), with more keyword queries instead; recency multiplies overlap rather than adding to it;
+the gate needs a shared keyword, a keyword-search hit, a card or a specific topic, and a score
+above 0.05. A keyword-search hit with no OpenAlex keywords counts as one shared keyword, so arXiv
+preprints found on the author's own terms keep their place.
+
+Second live run (same day, from the author's machine) showed the first fix overshot: narrowing
+the topic seed from five to two dropped the people who were only reachable through the third
+topic (they were not demoted, they were no longer found), and single-word keywords sent as
+literal queries to GitHub and Hugging Face returned VPN configs, an archiver and a game, each
+pushed today and lifted by freshness above real scientists. Corrected: the seed is all specific
+(non-bucket) topics up to five, since the df damping in score() is what makes buckets harmless;
+only phrases of two or more words go to code, model and preprint search, and a hit must carry the
+phrase contiguously in its name, description or tags; the keyword-search floor (0.15) earns no
+freshness. Lesson kept: a unit test on score() does not catch a loss at the discovery stage;
+the live run does.
+
+## 2026-11-08, distribution
+
+Vladimir's constraint, stated plainly: posting on his own channels has never moved anything, for any
+of his products. So the channels used are the ones where other people's audiences or the product
+itself bring the reader: a pull request to awesome-mcp-servers (Research section, #18892), a listing
+request on mcp.so (#6933), a release pipeline that publishes to PyPI by trusted publishing and to the
+official MCP Registry by GitHub OIDC on one tag (the user must register the pending publisher on PyPI
+once), six cluster pages under docs/clusters generated from real runs (pages people search for, each
+pointing back), and the product's own hands: propose_merge rounds to real authors, 10 issues a day,
+every text shown to the user first. Not done, by rule: Glama and Smithery need an account sign-in
+(his action); awesome-agent-skills refuses new skills without usage (submit in a month). The
+ceiling in this niche is known: idea-reality-mcp, 830 stars in eight months.
+
+Preparing the first round exposed four more things in the matcher and the plan: a cluster over 15
+is split into a batch (the living leader plus the most recently active) rather than refused; a
+sender who is not one of the authors says so in the first line ("Who is asking"); what a repository
+brings is its own description when no feature is unique, never an invented "working implementation";
+the merge target is the base repository, not a repository that does not exist. In the matcher: the
+verb of the idea is required but not counted (a note-UID generator is not a site generator), a
+distinctive job word must match (sessions-to-a-wearable is about the wearable), technical tokens
+(pii, nl2sql) are sharp for membership but cannot alone name a related repository ("mcp server"),
+and no merge is proposed where a 1000+-star leader has decided the field.

whoelse-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladimir Beskorovainyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

whoelse-0.1.0/PKG-INFO

@@ -0,0 +1,313 @@
+Metadata-Version: 2.5
+Name: whoelse
+Version: 0.1.0
+Summary: Who else is working on what you're working on? An MCP server that finds them, works out what you could build together, and drafts the first message.
+Project-URL: Homepage, https://github.com/beskvladimir-create/whoelse
+Author: Vladimir Beskorovainyi
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,arxiv,collaboration,github,huggingface,mcp,openalex,research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.2
+Requires-Dist: pydantic>=2
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# whoelse
+
+<!-- mcp-name: io.github.beskvladimir-create/whoelse -->
+
+**Don't build it alone.**
+
+Ask an agent to build something and it will, for the 21st time. Somewhere, twenty people already
+built it, each got ten stars, and three more are working on the same thing right now. None of them
+know each other.
+
+whoelse puts one call in front of the first line of code: what already exists, who won, what nobody
+has, and then the step no other tool takes: a plan to merge the small ones into one project with
+every author on it, or the person whose current work overlaps yours, with what the two of you could
+build and the first message drafted. Nothing is sent without you.
+
+Runs inside Claude, Cursor, Codex or any MCP client. No sign-up, no profile to fill in, no server. Free.
+
+```bash
+pip install git+https://github.com/beskvladimir-create/whoelse
+```
+
+![whoelse: what the agent says before writing a line](docs/demo.png)
+
+---
+
+## The problem
+
+Nobody is working alone on purpose. It just turns out that way: you publish, nothing happens, you go back to work. The person who would have cited you, tried your code, co-written the next paper with you, is two time zones away and has never heard your name. Discovery runs on conferences and luck, and most people get neither.
+
+whoelse replaces luck with a lookup, and then does something with what it finds.
+
+## Don't build it alone
+
+Idea checkers exist ([idea-reality-mcp](https://github.com/mnemox-ai/idea-reality-mcp) scores an
+idea against GitHub, HN and npm and stops at "here are similar projects"). whoelse starts where they
+stop. Ask your agent to build a tool:
+
+> Build me a CLI that syncs Claude Code sessions across machines.
+
+```
+"a CLI that syncs Claude Code sessions across machines" exists at least 40 times. The leader is
+tawanorg/claude-sync (320 stars, last pushed 2026-10-06); the other 39 have a median of 1.
+Between them: end-to-end encryption, Cloudflare R2, git-backed sync, Google Drive, LAN sync,
+Codex sessions, backup before the 30-day deletion. None of the 40 has a terminal UI, hooks,
+an Obsidian export, mobile, or cost tracking.
+
+Options: contribute the missing backend to claude-sync; build only what nobody has; or propose a
+merge to the small ones (propose_merge).
+```
+
+(Real output, 2026-11-08, unauthenticated GitHub search.)
+
+That is `find_duplicates`. It searches GitHub for the job the tool does (not the product it serves),
+keeps what is actually the same thing, ranks it, and builds a feature matrix: who has what, what only one of them has, what none of them
+has. The verdict comes first, in one sentence. Hundreds of hours of rebuilding the same thing, and
+the tokens spent on it, stop here.
+
+`propose_merge` goes one step further. For a cluster of small duplicates it writes the merge plan
+(the living leader as the base; what each repository brings, from its own README; every author a
+maintainer with write access; nothing deleted; a release date) and the text of one issue for each
+author, in their own repository, where they already read. The issues go out only after you have
+read them and said yes, from your GitHub account, all at once, so no author is asked to join
+someone else's project: all of them are asked to join one.
+
+GitHub's acceptable use forbids bulk unsolicited content, and so does common sense, so the limits
+are in the code: 3 to 15 living repositories per proposal, at most 10 issues a day, 3 seconds
+apart, never twice to the same repository (a local ledger remembers), never to an archived, forked, inactive or
+organisation-owned repository, one with issues turned off, one with 1000+ stars, or your own. One proposal is a conversation; forty is a mailing.
+
+### Put it in front of the agent
+
+`plugin/` is a Claude Code plugin (MCP server plus a `dont-build-it-alone` skill) that makes the agent
+call `find_duplicates` before it starts building anything the user describes. For Cursor, Codex and
+other MCP clients the same skill text goes into the rules file. The user sees what exists before the
+first line is generated, which is the only moment the information is worth anything.
+
+Real runs, one page per idea, live in
+[awesome-already-built](https://github.com/beskvladimir-create/awesome-already-built): session sync
+for Claude Code, arXiv MCP servers, PII anonymization for LLMs, token-cost dashboards, Obsidian site
+generators, DICOM in Rust. Add an idea there with an issue; fix your row with a pull request.
+
+## How it connects strangers
+
+Finding people is the easy half. whoelse is built around the hard half: two people who have never
+heard of each other end up working on one thing, fast.
+
+**1. The work starts before the first message.** `start_joint_work` builds a repository with the
+paper outline, section 1 drafted from both sides' published abstracts, a comparison table holding
+the numbers each side already published, a reproduction script pointing at both codebases, both
+names on the byline, and a 14-day plan. The other person receives a link to a third of a finished
+work. Saying yes is opening an issue titled "in". Saying no is ignoring it: after 14 days you
+finish alone and cite them.
+
+**2. Mutual matching without any letters.** `publish_request` puts what you want to build into an
+open registry (one JSON file per person, in a public GitHub repository; no account with us, no
+server). It publishes your name and email, so your agent shows you the file and asks before it
+goes. Anyone who installs whoelse with the same problem is matched to you. When both sides want the
+same format on the same problem, one watcher (the side whose name sorts first) creates the
+repository, invites the other, and emails both; the other watcher sees the repository appear and
+confirms, or takes over after three days of silence.
+
+**3. Nobody falls out of the queue.** If there is no match today, whoelse says so plainly:
+
+> Your request is published. 37 people are waiting in the network, none on text-to-SQL yet. When
+> one joins, the work starts by itself and a link goes to you@example.org. Nothing to do; just
+> don't remove whoelse.
+
+`whoelse-watch --loop 6h` keeps checking. The link arrives by email (your own SMTP, or GitHub's own
+notification when the repository is created and you are invited).
+
+**4. Strangers, by design.** People you already publish with are listed separately and never
+proposed. Requests that share an id with yours are skipped. Complementary assets score higher:
+your code against their data, their paper against your system.
+
+**5. Nobody's name goes public on the strength of a file.** A registry file is data written by a
+stranger. It must fit a strict schema; the registry's CI merges it only if `ids.github` is the
+login that opened the pull request and the file is not someone else's; the watcher acts on it only
+if that GitHub profile's display name is the name in the file. That proves the file belongs to that
+account, not that the account is the researcher it names, so the joint repository is created
+**private**, the account is invited, and it goes public only after they accept and say "in". If
+they never do, you finish alone and publish without their name, citing their work. A repository
+that already exists is never overwritten.
+
+## What you get
+
+Ask your agent:
+
+> Load my profile: Vladimir Beskorovainyi, ORCID 0009-0004-7005-6242. Who else is working on this?
+
+```
+25 people are working on what Vladimir Beskorovainyi is working on (personal papers; archives; text classification).
+4 can be written to today.
+
+ 0. Angelo La Gorga (Universidad Carlos III de Madrid): same problem: personal papers; active 2026-09.           reach: email
+ 1. Fabian Karl (Universität Ulm): same topic: computational and text analysis, text classification; active 2026-01. reach: email
+ 2. Lukas Galke (University of Southern Denmark): same topic: text classification; active 2026-01.                reach: email
+```
+
+> Start a comparison note with Ada Example (illustration; the names below are made up).
+
+```
+Repository: github.com/you/you-example-text-to-sql
+  paper/paper.md     outline; section 1 drafted from both abstracts; table with published numbers
+  repro/run.py       both methods, same data, same metric; each side fills its half
+  PLAN.md            14 days to a preprint
+  CITATION.cff       both names
+Send this: three sentences, the link, one yes/no question. To: ada@example.org (from her whoelse card)
+```
+
+> Publish my request: a comparison note on text-to-SQL for closed enterprise data, by December.
+
+```
+Your request is published. 2 people are waiting in the network; 1 wants what you want: Ana Example
+(illustration), text-to-sql, has a dataset you don't. Joint work can start now.
+```
+
+## How it finds people
+
+Three directions at once, then merged into people:
+
+| direction | source | what it catches |
+|---|---|---|
+| papers | OpenAlex keywords and topics; arXiv for preprints OpenAlex hasn't indexed yet | who published on your exact problem in the last 24 months |
+| code | GitHub repository search | who is building it |
+| models and data | Hugging Face Hub | who released weights or a dataset (quantisations and repacks are filtered out) |
+
+A GitHub login, a Hugging Face account and an OpenAlex author become one person only when a second signal says so: the same affiliation, a link from their paper to that account, the same website. A shared name alone keeps them apart, flagged as possible namesakes, so one person's email never lands next to another's work. Organisations (a company's GitHub, a lab's Hugging Face) are recognised and left out. Authors who link their own code in an arXiv comment are joined automatically, including you: give whoelse your name and it usually finds your handles itself.
+
+If several people share your name, whoelse does not guess. It shows you the namesakes and asks for an ORCID or an affiliation.
+
+A third reach channel, GitHub user search by full name, is used only when it returns exactly one account whose repositories are about the same subject; otherwise it is ignored. On real data it finds roughly one in three researchers who left nothing on ORCID.
+
+## How it reaches them
+
+Only through what the person published about themselves, and every contact says where it came from:
+
+- ORCID: public email, personal site, GitHub, Scholar, LinkedIn (limited-visibility emails are never read)
+- GitHub profile: public email, website
+- Their own website: a whoelse card, if they have one
+
+arXiv submitter emails are never touched. arXiv's terms forbid using them for unsolicited contact, and we don't need them.
+
+## The network
+
+A public GitHub repository, `beskvladimir-create/whoelse-network`, with one JSON file per person
+under `people/`. Your agent opens the pull request (with a `GITHUB_TOKEN` that has `public_repo`
+scope), or writes the file and tells you where to put it. Calling `publish_request` again renews
+or updates your file on the same branch. Requests expire after three months. Reading needs no
+account. There is no server and nothing to sign up for; the repository is the directory. The
+registry's own CI and README are in `registry/` in this repository.
+
+`whoelse-watch` reads it fresh every pass (the registry is never served from cache), matches your
+request against everyone else's, and when two people want the same format on the same problem it
+builds the workspace, creates the repository, invites the other side, and emails both; once per
+pair, with state saved after every step. Run it from cron or launchd:
+
+```
+0 */6 * * *  whoelse-watch
+```
+
+## The card: connected mode without a server
+
+Put this on your own site at `/.well-known/whoelse.json`:
+
+```json
+{
+  "name": "Ada Example",
+  "working_on": ["text-to-SQL on open-weight models", "schema linking"],
+  "open_to": ["co-author", "joint benchmark", "talk together"],
+  "contact": "ada@example.org",
+  "languages": ["en", "pt"],
+  "updated": "2026-11-07"
+}
+```
+
+Anyone running whoelse now sees you as **connected**: reachable, and open to exactly what you said. When both sides have a card, both of you are one `joint_work_brief` away from the same proposal; sending it to both at once is on the roadmap. No registry, no account, no central anything. The web is the directory. `make_card` writes yours.
+
+## Your people
+
+Once you've decided someone is one of yours (`add_peer`), whoelse watches what they ship and tells you when there is something to support: a repo to try and star, a paper to cite or argue with, a model to run on your data and report back. It never stars, follows or likes anything for you. GitHub names automated starring and following as rank abuse, and a circle that fakes its own signal is worth nothing to the people in it.
+
+## Tools
+
+| tool | what |
+|---|---|
+| `load_profile` | your profile from OpenAlex, arXiv, GitHub, Hugging Face, ORCID |
+| `find_overlaps` | people whose recent work overlaps yours, ranked, with reasons and public contacts |
+| `joint_work_brief` | one person: the evidence, what each side has, formats ranked by fit and effort, venues in common |
+| `draft_outreach` | facts and structure for the first message; your agent writes it, you send it |
+| `add_peer`, `remove_peer`, `whats_new_from_peers` | your people and what they shipped this month |
+| `find_duplicates` | before building: what exists, who won, what nobody has |
+| `propose_merge` | a merge plan for a cluster of duplicates and one issue per author (sent only on your yes) |
+| `publish_request` | join the network: what you want to build, with whom, by when |
+| `start_joint_work` | a repository with a third of the work done and both names on it |
+| `make_card` | your `/.well-known/whoelse.json` |
+| `list_known` | profiles and peers on this machine |
+
+## Install
+
+```bash
+pip install whoelse            # or: pip install git+https://github.com/beskvladimir-create/whoelse
+```
+
+Claude Code: `claude mcp add whoelse -- whoelse`
+
+Claude Desktop, Cursor, Codex and others, in the MCP config:
+
+```json
+{ "mcpServers": { "whoelse": { "command": "whoelse" } } }
+```
+
+Optional environment:
+
+| variable | effect |
+|---|---|
+| `WHOELSE_OPENALEX_KEY` | free key from openalex.org/settings/api; without it you share a small per-IP daily budget |
+| `WHOELSE_MAILTO` | your email for OpenAlex's polite pool; sent nowhere else |
+| `GITHUB_TOKEN` | raises GitHub search limits (any scope); `public_repo` scope is needed for `publish_request`, `start_joint_work` and the watcher |
+| `WHOELSE_SMTP_HOST`, `_PORT`, `_USER`, `_PASS`, `_FROM` | the watcher's email, sent from your own address; without them, notifications land in `~/.whoelse/inbox/` |
+| `WHOELSE_HOME` | where profiles, peers and cache live (default `~/.whoelse`) |
+
+## What it will not do
+
+- Send a letter for you. Drafts are yours to send, from your own address, one person at a time.
+  The only automatic messages are the watcher's: to you, and to a verified stranger, once, with a
+  public repository link, after you joined the network and confirmed what gets published.
+- Use a contact the person did not publish themselves (their ORCID, their GitHub, their own card,
+  their own registry file).
+- Star, follow, like or post on your behalf.
+- Keep anything about you anywhere but your machine, except the registry file you confirmed and
+  the joint repositories you asked for.
+
+## First run on your own name
+
+```bash
+WHOELSE_MAILTO=you@example.org python -m whoelse.scripts.first_run "Your Name" --orcid 0000-0000-0000-0000
+```
+
+Prints the people, the reasons, the best format for each, and how to reach them; saves everything to `whoelse-first-run.json`. Nothing is sent.
+
+## Develop
+
+```bash
+git clone https://github.com/beskvladimir-create/whoelse && cd whoelse
+pip install -e ".[dev]"
+pytest                                                      # offline, on recorded fixtures
+WHOELSE_FIXTURES=tests/fixtures python -m whoelse.server    # offline demo server
+```
+
+Sources: [OpenAlex](https://openalex.org) (CC0), [arXiv](https://arxiv.org) (CC0 metadata), [ORCID](https://orcid.org) public API, [GitHub](https://docs.github.com/en/rest), [Hugging Face Hub](https://huggingface.co/docs/hub/api). All keyless.
+
+MIT.