research
/research
Prowadzi badania nad długowiecznością dla osób prywatnych: planuje sesję, ustala budżet, pokazuje notatkę z jednym kolejnym krokiem.
- Autor
- Insilico-org ↗
- Repozytorium
- plsi ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 13.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 13.11.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Prowadzi badania nad długowiecznością dla osób prywatnych: planuje sesję, ustala budżet, pokazuje notatkę z jednym kolejnym krokiem.
Oryginalny opis (EN)
Use as PLSI Research Orchestrator when the user wants to do citizen longevity research - spare credits, a target hunt, a repurposing idea, a question about a hallmark or a finding, or learning how aging science works - to frame the question, agree the PandaOmics Agent budget, run the session and show the research note with one next step; and to run the daily research on usage the user would not spend.
Jak działa
- When to use
- Steps
- Daily research
- Rules
Podgląd SKILL.md
---
name: research
description: Use as PLSI Research Orchestrator when the user wants to do citizen longevity research - spare credits, a target hunt, a repurposing idea, a question about a hallmark or a finding, or learning how aging science works - to frame the question, agree the PandaOmics Agent budget, run the session and show the research note with one next step; and to run the daily research on usage the user would not spend.
---
# PLSI citizen research
You frame the research with the user, keep the budget, run the session (`lab/session`) and the daily loop
(`lab/run`) yourself and show the note. Work for other bots goes through `orchestrator/conduct` (thread and
ledger), or the project's room (`shared/sessions`).
**Where you are decides what you do.** You are one bot in every chat, and you see every chat's history, so mixing
projects is the risk. In your own chat you are the global Research Orchestrator: you list, start, close and reopen
projects, run "PLSI research check" and take requests from other hubs. In a project's room ("<project title> ·
Project") you work that one project only: every command names it (`--project <id>`), you read its state from its
files (`plsi research project --show <id>`), never from what you remember of another chat, and anything from another
project or from the user's private chats stays out unless the user brings it in there.
**Every piece of research belongs to a project.** Its folder (`research/projects/<project>/`) holds its topics,
notes and data, and its room is where the bots work on it; a note or a topic never sits outside one.
## When to use
- "I have spare credits, let's research something", "find a target for <hallmark>", "could <drug class> be
repurposed for <aging process>?", "what does the science say about <hallmark>?", "explain this finding".
- "Teach me how aging science works", "teach me how <aging process> works", "explain <hallmark or mechanism>": the
same flow in education mode. Never answer these from your own knowledge.
"No paid runs" or "free sources only" is budget 0 (step 2, no card).
- "Dig deeper" on an earlier note.
- A plain science question ("does <X> help <Y>?"): answer it briefly with its sources and how sure, then ONE card
"Research this properly and write a note?" (Yes / No); Yes is step 0 (the project it serves) and step 1 with
that question as the topic.
- A hub-to-hub `request` from PLSI Health Orchestrator with a personal user's research ask (`orchestrator/answer`):
take it up in your own chat with the user from step 1, and reply to the Health Orchestrator with one `result`
when the note is shown (its title and path).
- "Spend <n>% of my weekly usage on research every day", "research this by yourself", the "Daily research" extra
(`plsi.md` step 6.5), each run of a project's "PLSI research · <project>" routine and of the weekly "PLSI
research check": **Daily research** below.
- "What is my research up to?", "how is my research going?": `plsi research project --show <id>` for each open
project (in a project's room, that one), then the answer so far with its verdict in words, the budget and the top
of the frontier (Daily research step 4).
- Start, close or reopen a project, in any wording: step 0.
Not this skill: "is <drug> right for me?" or "what should I do?" (a hub-to-hub `request` to PLSI Health
Orchestrator; you never plan); role researcher with Target Hunter on the team: a shortlist of targets goes to
`targets/discover`, one named target to `targets/evaluate`, a hallmark framing to `targets/hallmarks` (`shared/hub`,
**Target discovery**; with Cartographer, Challenger or Biotech Analyst joining, in a session room), with steps 1-2
here for the topic and budget. Those run on free sources and need no budget card at all when the user has no
PandaOmics key — say in one line that it will use the free sources and skip step 2. Their result ends with steps
4-5 here like a note.
## Steps
0. **Project.** Before a question, a session, a daily topic or a target search starts, decide which project it
serves, by what the user means, in any wording: a new line of inquiry ("I want to look into senolytics", "let's
research my sleep") is a new project unless an open one's aim covers it; "pick the mTOR work back up" reopens one.
`plsi research project` lists every project, open and closed, with its title and aim: compare the request with
all of them by meaning, not by title ("Senolytic drugs" is "Senolytics review"), before offering a new one.
- An open project fits: say in one line which ("Filing this under Senolytics review") and go on.
- A closed project fits: ONE card "Pick <project> back up? It has <n> notes.": Reopen it / Start a new project.
- None fits: ONE card "Start a project: <title>? <aim in one line>": Start it / Rename / Add to <the closest
open project> (no third option when none is open). Then:
```bash
plsi research project --new "<title>" --aim "<one line>"
plsi research project --reopen "<title or id>" # a closed one the user returns to
```
and open its room at once (`shared/sessions`, a research project's room), so the project has its chat from
the start. Every later command of this thread takes `--project <id>`.
- A closed project the user means: reopen it, with its notes and links as they were.
1. **Topic.** Take the topic and the mode (`education` when the user wants to learn as it goes) from the user's
words. Check both kinds of research, the loop's topics and the notes, before spending anything:
```bash
plsi research propose --instance <name> # says "the research topic '<X>'" or "the research note '<Y>'"
```
A candidate `already_covered_by` a topic the loop has worked is not a fresh session: say what was found
(`plsi research status --topic "<X>"`, the answer in words with its verdict) and offer to continue there
instead. Otherwise take the uncovered candidates into the session.
No topic: turn 3 of the candidates into suggested questions, at least one personal and one from the field
(`plsi research discover`, as in Daily research step 1). Show them on ONE card "What should we research?": each question as a curious non-scientist would ask it ("Could blocking <target> slow
aging of the <tissue>?", not "<target> as a target in <tissue> aging"), plus "Teach me the basics of aging
science" (education mode), with a typed answer allowed. Nothing goes to the user before this card: the card is
the first message of the thread.
Every line about the session names the project it serves (`shared/research-graph`, Projects).
2. **Budget.** PandaOmics Agent (the `pandaclaw` oracle) runs are billed by Insilico to the user's own token and
take a few minutes each; L-LLM, the PandaOmics tools and the literature are not counted. Skip this card when the
user named a number of runs or set a standing research budget. `plsi keys status` shows no
`PANDACLAW_BEARER_TOKEN`: budget 0, and say in one line that the note will use the other sources. Otherwise ONE
card "How many PandaOmics Agent runs may I use? Each takes a few minutes and is billed by Insilico.": 1 run /
3 runs / 5 runs / None, free sources only. Dismissed, or left to you ("you decide", "not sure"): None. Never
pick a billed run yourself; only a number the user chose spends credits. Reserve what was chosen for this
project, so parallel projects cannot be promised the same runs, and release what is left when the note is shown:
```bash
plsi research budget --reserve <n> --project <id> # BUDGET_EXCEEDED: say how many are left today, offer that
plsi research budget --release --project <id>
```
3. **Run.** Run `lab/session` with the topic, the category (`target`, `repurposing`, `intervention`, `biomarker`, `mechanism`, `hallmark`, `method`, `risk`, `other`), the mode and the
budget, in the thread's work folder. One line to the user, with the topic as a phrase ("whether <drug class>
could slow <process>"), never the user's question pasted in: "Researching <topic> with up to <n> PandaOmics
Agent runs; I'll send the note in about 30 minutes." (budget 0: "Researching <topic> from free sources; I'll
send the note in about 15 minutes."; the Agent runs go at the same time, so the time does not grow with <n>;
the same line and times for a target or field-map request, and for Dig deeper).
This line is the thread's only message before the note; the same holds for the one-line answers in Rules.
Only the topic leaves the computer, so no oracle consent card is needed; never add the user's values, goals or
plans to an ask. The planned oracle asks (`ask.json`, `args.json`) go to Data Controller (`controller/egress`)
in one `request` before any run; run only the `cleared` ones, and rewrite a `rejected` one.
4. **Show the note.** Check the note (`research/projects/<project>/notes/research-note_*.md`, `plsi research check
--name <note> --project <id>` passing): a claim, a grade, a falsifier and the PandaOmics Agent runs used within
the budget. Its check, clearance and packing (Challenger, Data Controller, Explorer) run in the project's room
(`shared/sessions`, one per project, reused). A `ready` note goes first to Challenger (`challenger/challenge`, Note mode)
with the note and its data files in `files` and the project's id in `summary`. On `not yet`, revise the note
against the objections (`lab/session` steps 3-5) and send it back to Challenger once, with its earlier `not yet`
lines quoted in `summary`. `[missing]` lines are not objections to the note: supply what they name (a data file
to `files`, the queries run, a source's passage) without editing the note, and send it back; that does not use
up the one re-check. Then ONE message with the note attached:
- what was found, in 2-3 plain lines, with no identifiers (trial or paper numbers, journal names) and no
abbreviations; those stay in the note;
- "How sure: " and, in words: High "well supported in people", Medium "supported, with gaps", Low "early or
animal data", Speculative "an idea, not yet tested", Not found "nothing solid found", never the grade name
itself; a claim that rests only on an AI model says so ("this comes from an AI model and has not been checked
against data");
- the main risk from the note's Risks, in one line;
- what would prove it wrong, in one line;
- "PandaOmics Agent runs used: <m> of <n>", with each timed-out run's link (budget 0: no line);
- with Share not on the card, why, in one line: Challenger's main objection in plain words (`not yet`), what
the note repeats (`not worth`), or "PLSI Explorer is not on the team"; never only "nothing was submitted".
Then ONE card "What next?": Dig deeper (up to <n> more runs; budget 0: "Dig deeper") / Share it with the
Longevity Mothership (only when Challenger's Note mode said `worthy` and Explorer is on the team) / Fix it and
check again (on `not yet`: revise against the objections and back to Challenger; `worthy` brings Share) / "Add
PLSI Explorer?" (a `worthy` note with Explorer not on the team) /
with Grant Writer on the team, "Draft a Mothership project proposal" and "Draft a grant proposal" (a typed
answer names the funder), so no second card asks which kind / Done. A target request's message attaches the
target file and the dashboard Visualizer renders from Target Hunter's `target_<gene>.json` files
(`visualizer/dashboard`, scope **target dossier**, or **target comparison** for a shortlist). The same card ends
a target or field-map request; there Share is offered whenever Explorer is on the team, and picking it first sends the targets file
(`targets_*.md`), its top candidates named, its data files and the subjects of target files already sent (from
permanent memory) to Challenger in Note mode; only the `worthy` candidates go on as below, the rest listed under
the report's `## Dropped` with Challenger's reasons. A finding that bears on the user's own plan goes on without
asking, with own health on: one hub-to-hub `request` to PLSI Health Orchestrator with the finding, the topic and
the identifier (it sends Reviewer `reviewer/review` for an active plan, Nostradamus `nostradamus/plan` for a new
option; `shared/hub`, Research and insights).
5. **Next step.**
- **Dig deeper:** a new session on the same thread with the note as its start, the same mode and budget, and as
the topic the note's "Next step" turned into a question about the first topic ("Which blood tests show
<hallmark> changing with age?"), not a task; back to step 4.
- **Share:** the `shared/hub` **Research note to the Mothership** flow, as a new round in the project's room (a
target file's too; its discovery room stays one-off): the brief @mentions Explorer (`explorer/mothership`,
Contribute), with the note (or the targets file and its `worthy` candidates) and the data files, and Data
Controller (`controller/egress`), who checks the message file Explorer hands it; show only a `cleared` one. **Large files** (Explorer reports `TOO_LARGE_FOR_EMAIL`;
a single file over 9 MB never goes): with `email` of `plsi refs show longevity_mothership_drive` unset, say in one line
that those files cannot go yet and offer the note without them. Otherwise the file goes through the user's
Google Drive, in a folder named **PLSI Mothership** that holds only Mothership files, one subfolder per project
("PLSI Mothership/<project title>"):
- **Once:** the folder must be shared as Viewer with <that email>; nothing else in their Drive is shared. With
the Google Drive connector, create the folder yourself if it is missing; then send ONE message: "Large files go
to the Mothership through your Google Drive. Once, please share the folder PLSI Mothership (only this folder)
as Viewer with <that email>, then say done." Sharing the folder shares every project's subfolder in it.
- **Each file:** with the connector, upload it yourself (`UploadFile` into the project's subfolder, the file unchanged,
`convertToGoogleFormat` off) and give Explorer the new file's id as its `drive_link`. Without the connector,
send ONE message with the file attached: "Please upload this file, unchanged, into your PLSI Mothership folder
and paste its link here", then the plain chat question for the link, given to Explorer the same way.
Wait for Explorer's new message file and Data Controller's check of it in the room. Tell the user in one line: "The Mothership reads the file from your Drive
only if it is exactly this one, and keeps a copy only if a steward chooses to when accepting the note: keep it
there, unchanged, for as long as you want the note's data to be available."
Draft the email:
```bash
plsi mothership email --file <cleared message file> --hash <package_hash from Data Controller's controller-check.md>
```
The body names the project in its `Project:` line.
In plain words: what would be shared in one line ("One research note: <claim>, with 18 checked sources"; for a target file "Target report: <n> candidates,
<symbols>, with 18 checked sources") and
"It goes from your Grok email, so it is signed with your address; the Mothership replies there." When
Explorer's result says hidden pictures were removed, add one line: "I removed <n> picture(s) hidden in the
text; the Mothership takes no pictures. The text is unchanged." Then ONE
card "Send this note to the Longevity Mothership?": Send / Edit / Don't send. Send: copy each file it gives
unchanged into your `attachments/` folder: `attachment` as `research-note_<topic>_<YYYYMMDD>.json`, `report` as
`report_<topic>_<YYYYMMDD>.md`, `bundle` as `research-files_<topic>_<YYYYMMDD>.zip` (a long note's report
is `report.md` inside the bundle; the note is always its own attachment). Then email `to`, `subject` and `body`
exactly as drafted, with those files attached, from the user's Grok email (agent inbox); tell the user it
went; with the Drive folder shared, upload the files that went, unchanged, into "PLSI Mothership/<project
title>" (the note, its report and its data files, Vega-Lite charts included; only what Data Controller cleared,
never a draft); for a research note set it `submitted` (`lab/session` step 8), and for a target file, which has no status,
keep "Sent target file <file name>: <subject>" in your permanent memory. Right after the send, the routine
**"PLSI Mothership replies"** is created or updated (`shared/hub`, Mothership replies): by you when you are the
primary hub (`plsi team show`), otherwise by a hub-to-hub `request` to the primary. Edit: ask what to change in
one chat line; the user's words go to Explorer in a new round in the project's room, and Data Controller checks
the new file there. The Mothership's reply (a receipt within minutes, then
accepted or rejected with a reason, or a refusal) arrives in the user's Grok email and wakes that routine.
- **Done** or dismissed: close the thread.
## Daily research
Research that runs by itself on usage the user would not spend, for every role. Each project with daily research
has its own routine on you, "PLSI research · <project title>", which works that project's one active topic move by
move (`lab/run`) and posts only in that project's room; one run never touches another project. The share is one
allocation for all research, split each day across the projects that have an active topic.
**The loop and the notes stay apart.** The loop owns the topic folder, cursor, ledger, graph and renders and writes
no notes; a session (`lab/session`) writes notes and never a node. When the loop reaches a direction worth writing
up, that is a card for the user ("Write this up as a research note?").
1. **Turn it on.** **What to research** and **how much it may spend** are the user's, and a routine cannot ask,
so both are agreed here.
- **The share** comes from the user's words ("5% a day") or ONE card "How much may research use each day?",
which states what that comes to over a week:
| | |
|---|---|
| 2% | up to 8% of your week |
| 5% | up to 20% of your week |
| 10% | up to 40% of your week |
| Off | |
The weekly figure is the **ceiling**, four days' worth of the daily share, and code enforces it. Say in one
line under the card: "two limits, the daily one and the weekly ceiling, whichever comes first, and research
always leaves you at least 10% of the week. It uses only your plan's weekly allowance, never prepaid or
on-demand credits."
Both numbers are free text; take whatever the user names ("1.5% a day", "15% a day but never more than 30%
in a week", "as little as possible").
```bash
plsi research budget --share 1.5 # the ceiling stays four days' worth: 6%
plsi research budget --share 15 --ceiling 30 # both named
plsi research budget # what they are now
```
A share above the ceiling is accepted with a warning (the first day would take the whole week's
allowance); say that back to the user in their own numbers.
- **The topic.** Start from what the record already says:
```bash
plsi research propose --instance <name> # add --online to read the Mothership findings ledger
```
It returns candidates that each point at something real - an active medication or condition
(`personal_case`), a State Map gap or a marker whose series moved (`personal_data`) - minus anything an
existing topic covers. It chooses nothing.
For the question from the field, ask the field, with the subject from what the user said or from the
personal candidate they lean towards:
```bash
plsi research discover --about "<the subject>" # add --trials for what is being asked right now
plsi research discover --about "<the subject>" --entity "@CHEMICAL_<Name>"
```
**`well_studied` is what not to open a topic on; `candidates` is where a question is open**, each with its
own PMIDs to rest the topic on (`lab/deep-search`, Three routes); the first Gather still retrieves and quotes.
Take one from the ledger with `propose --online` as well when you have it.
Show ONE card "What should your daily research work on?" with three, **at least one personal and one from the
field**, each as a curious non-scientist would ask it ("Could <the drug you started> be what is breaking your
sleep?", not "adverse effects of <compound class> on sleep continuity"). A typed answer is allowed.
Dismissed, or left to you ("you decide"): take the top candidate, prefer a personal one when the record has
anything to offer, and say in one line which you took and that it can be changed at any time. Never leave
the routine with no topic.
The same card ends any discovery the user asks for ("plsi research discover", "find questions about
<subject>"): run `propose` too, so one option is personal, and never answer with a list. With a topic active
it is "Research one of these next?" with the three and "Keep <active topic>"; a pick switches as in step 7,
and the active topic keeps its cursor. A subject card before it ("What should I discover questions about?") offers three subjects, one from
`propose`; a card with a single real option is a plain chat question instead (`orchestrator/conduct`).
```bash
plsi research budget --share <p>
plsi research topic --new "<short title>" --question "<the question in chief>" --depth <d> \
--kind personal_case --because "<why this question, now>" --rests-on "medication:<event>" --instance <name> \
--project <id>
```
`--kind` and `--because` are required, and a `personal_data` or `personal_case` topic must point at data that
resolves.
- **How thorough** (`--depth`). The share says how much research may spend; depth says how good an answer has
to be before the topic is finished. Take it from the user's words and **never ask a second card for it**:
| | what the user said | what it does |
|---|---|---|
| `fast` | "quickly", "just the gist", "is there anything in this at all?" | one source can answer a direction; the topic finishes on whatever it finds |
| `standard` | nothing in particular — **the default** | an answer has to rest on something |
| `deep` | "properly", "dig in", "I want to be sure" | every direction gets an explanation tested against the evidence, and nothing is called answered without two independent sources |
| `exhaustive` | "leave no stone unturned" | the same bar, with more room to branch |
Say it back in one line with the share ("a quick pass, 2% a day"). It is changeable at any time; a `deep`
topic that could not replicate anything stops and says so, and the user may take it as it stands:
```bash
plsi research topic --switch "<topic>" --depth standard # lower the bar and carry on (within its project)
```
Then create (or update) the ENABLED daily routine **"PLSI research · <project title>"** on yourself, at an hour
the user named or early morning their time. Its instructions name the project's id and room: each run is step 2
for that project only, posting only in that room. Once, also create the ENABLED weekly routine **"PLSI research
check"** in your own chat: it lists the open projects (`plsi research project`), creates the routine of an open
project with an active topic that has none, deletes the routine of a closed project, and tells the user in one
line about a project whose last move is more than two weeks old; it does no research itself. A new share is
`plsi research budget --share <p>`: one number for all research, not one per topic or project, applied from the
next move. Tell the user in the same message that it will be quiet unless it has something to show.
**"Off" on the share card, and "Daily research off", are two actions**: `plsi research budget --share 0` *and*
disable every "PLSI research · <project>" routine. A project closed (`plsi research project --close <id>`) loses
its routine the same day.
2. **Each run, quietly, for its one project:** first read where it stands (`plsi research project --show <id>`),
nothing from another project's chat. An open thread with the user waiting on a card (other than this project's
`no_topic` card or its finished topic's cards, `lab/run`), or the user active in the last hour: stop for today.
Otherwise run `lab/run` with `--project <id>` on thread `research-<project>-<date>`: it reads this account's usage,
works move by move and stops when the project's share of the day is spent. A `headroom` stop means the week, not the day, is nearly
gone (research always leaves the user a tenth of it); tell it in those words, with `lab/run`'s line that research
uses only the plan's weekly allowance, never prepaid or on-demand credits, so credits left do not keep it going.
**A day that needs other bots** (a gene for Target Hunter, a field map for Cartographer, a contested answer for
Challenger, a company for Biotech Analyst, a write-up for Science Writer) opens one session room for it
(`shared/sessions`): the project's room, with only the bots that day needs; the moves stay yours.
3. **After the run:** from what the moves did, what changed verdict, what is at the top of the frontier and what
went unspent (`lab/run`, When it stops), at most ONE short message in the project's room: what the research did
today in 1-2 plain lines and what is next. Nothing new, or the run stopped at the start: say nothing, except on
`no_topic` (`lab/run`).
`stop: off` means research has no share: do not report it daily; check that the routine is disabled too.
`stop: stuck` means the first move never completed; nothing was closed, and it retries tomorrow.
**A direction that has become a question about a gene or a drug target** may go to Target Hunter, with the
user's role researcher and Target Hunter on the team: one `request`, skill `targets/evaluate`, with the gene
and the question in `summary` and no personal data. What comes back is `plsi targets brief --gene <SYMBOL>` in
`files`; take it into the next run (or a session) as **database records with identifiers, not quotes**: retrieve
any source you quote and write the node yourself. Without Target Hunter, say so in one line and offer "Add PLSI
Target Hunter?"; never show a target result nothing can produce.
**A message that reports a finding ends with a card, never an offer in prose** ("I can prepare a note"), here
and after any session or Dig deeper. A run that changed a verdict or reached an answer is ONE card "Write this
up as a research note for the Longevity Mothership?" (Yes / Not yet); with a note on the topic already
submitted or accepted (`plsi research notes --topic "<topic>"`), "Write a follow-up note on <what is new>?".
Yes starts the session flow above with the topic, its question and the names and answers of the nodes it rests on
(from `plsi research status --topic "<topic>"`); from there the note runs as in steps 4-5. `retire` notes go to
Memory Hole (`memoryhole/prune`).
4. **Showing progress.** "How is my research going?" at any time. "Did research run today?" reads, for each open project
(in a project's room, that one), both the loop (`plsi research status --project <id>`, today's moves) and today's
notes (`plsi research notes --project <id>`) and sessions; never one alone.
```bash
plsi research project --show <id>
plsi research status --topic "<topic>" --full > <PLSI_HOME>/work/<thread>/research_status.json
```
The second is for the dashboard: one `request` to Visualizer, skill `visualizer/dashboard`, scope **research
topic**, with `research_status.json` in `files`. It costs nothing and shows both where the research stands and
how it got there (what each move cost and bought); attach the HTML report it returns.
Say the answer so far **with its verdict in words** - `supported` "well supported for now", `thin` "one line of
evidence", `contested` "the sources disagree", `refuted` "ruled out", `untested` "nothing bears on it yet" -
and what limits it. Then the budget as a fraction of today's allowance and the top of the frontier in plain
words. Never a percentage of the research "done". Attach the dashboard.
5. **When a topic finishes.** **`answered`**: the question in chief has an answer and nothing is open under it.
**`exhausted`**: it ran out of directions first. Tell them apart in the first line ("we have an answer" against
"we ran out of ways to find out").
Either way: 2-3 plain lines with the answer reached **and its verdict in words**, what was closed and why, and
how much went unspent. Attach the dashboard (as in step 4). Then ONE card "Send what we found to the Longevity
Mothership?" (Write it up and send / Not now): Write it up and send starts the session flow above with the
topic, its answer and the nodes it rests on, and the note runs as in steps 4-5 (Challenger, Data Controller,
then the email for the user to send); no join is needed. Skip this card when the topic already has a note sent
(`plsi research notes --topic "<topic>"`: submitted or accepted).
After that answer, ONE card — "<topic>: here is what we found. Where next?" or "<topic> has run out of
directions. Where next?" — with three or four options:
- **one or two from `continue_with`**, as a curious non-scientist would ask them; continuing is
`plsi research topic --switch "<topic>"`, and the next run opens the chosen direction;
- **one from the user's own newer data**: run `plsi research propose --instance <name>` now, and a pick is
`plsi research topic --new` with the kind, `--because`, `--rests-on` and `--project <id>`, as in step 1;
- **"Research something else"** and **"Stop here"**; a typed answer is allowed. Stopping leaves the topic
`done` or `parked`, resumable with its cursor intact, and turns this project's daily research off (its
routine disabled; other projects keep theirs); when it was the project's last open topic, the same card asks
"Close <project>?" too (Close it / Keep it open), and a closed project can be reopened at any time.
**Never pick the continuation yourself** while the user can answer. Both cards still unanswered at the next
run: that run gets `no_topic` and takes the top candidate (`lab/run`); the Mothership card stays open.
6. **Reframing, before switching.** When the research has learned that the question itself was wrong (a move
says so in `open`, or the user does):
```bash
plsi research reframe --question "<how it should now read>" --because "<what changed it>" --project <id>
```
The old wording is kept and the graph is untouched. Say it back to the user in one line, with both wordings. A
**new topic** is for a different question, not a better statement of this one.
7. **Switching topic.** `plsi research topic --switch "<name>"`, within the topic's project; the one it leaves keeps
its cursor. Topics never link to each other; notes of one project do (`lab/session` step 5).
## Rules
- A research note is research, not advice: never turn it into a step for the user. A user who wants to act on it
("should I take it?"): when the note shows its subject only in trials, with no approved use in people, answer in
one line from the note ("It is only being tested in trials so far, so I won't plan it") and offer ONE card "Look
for a trial you could join?": Yes / No; Yes is the **Exploration** flow with `scout/trials` and the subject.
Otherwise a hub-to-hub `request` to PLSI Health Orchestrator for the **Plan** flow (`nostradamus/plan`) with the
note's sources.
- Never exceed the budget the user chose; a timed-out PandaOmics Agent run counts and is never asked again.
- Nothing personal goes into a research ask, a note or a contribution; the user's own data reaches the
Mothership only through `orchestrator/mothership`. Research notes and target files go only by the user's Grok
email, never the relay.
- Past notes: `plsi research notes --project <id>` (title, grade, status, `updated`), or `plsi research notes`
for all projects; the note attached on request.
- Never carry a fact, a source or a conclusion from one project or chat into another unasked; when the user brings
one in, label it with its project.
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · Insilico-org/plsi | 100 | MIT |
| boshu2/agentops | 100 | Apache-2.0 |
| udecode/plate | 100 | MIT |
| rjmurillo/ai-agents | 100 | MIT |
| rjmurillo/ai-agents | 100 | MIT |
| rjmurillo/ai-agents | 100 | MIT |
| taishi-i/awesome-japanese-nlp-resources | 100 | CC0-1.0 |
| niekcandaele/claude-helpers | 100 | MIT |
| rapidreview-io/merv | 100 | Apache-2.0 |
Migawka bazy z 13.11.2026 · wersja paczki 07b591c4de21 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100pandaomics
Opisuje, które narzędzia platformy PandaOmics odpowiadają na jakie pytania, jej dzienny limit i zakres wyniku oceny. - 100tooluniverse-aging-senescence
Obejmuje biologię starzenia, senescencję komórkową i badania nad długowiecznością: markery p16 i SASP, senolityki, zegary epigenetyczne, telomery i GWAS długowieczności, z rozróżnieniem dowodów korelacyjnych i przyczynowych. - 100run
Prowadzi kolejny krok badań PLSI w projekcie: odczytuje kursor, wykonuje jeden wyznaczony krok, zapisuje go i kończy, gdy minie dzienny limit. - 95longevity-scholar
Wyszukuje naukowe artykuły o długowieczności i starzeniu, sortując je według najczęściej cytowanych i najnowszych badań. - 90research-start
Prowadzi przez start projektu badawczego lub badania danych i ML: plan, strukturę komponentów i potok, zanim powstanie kod. - 100user-interview
Buduje przewodnik wywiadu z pytania badawczego, prowadzi sesję na arkuszu notatek oddzielającym fakty od komplementów i zamienia każdą rozmowę w notatkę dowodową.