@synapse-research/synapse 0.2.12 → 0.2.13

package/dist/public/synapse-plugin/hooks/hooks.json

@@ -1,125 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "startup|resume|compact",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-session-start.sh"
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-user-prompt.sh"
-          }
-        ]
-      }
-    ],
-    "PreToolUse": [
-      {
-        "matcher": "EnterPlanMode",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-pre-enter-plan.sh"
-          }
-        ]
-      },
-      {
-        "matcher": "ExitPlanMode",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-pre-exit-plan.sh"
-          }
-        ]
-      },
-      {
-        "matcher": "Task",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-pre-spawn-agent.sh"
-          }
-        ]
-      }
-    ],
-    "PostToolUse": [
-      {
-        "matcher": "mcp__synapse__synapse_submit_experiment_results|synapse_submit_experiment_results",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-post-submit-results.sh"
-          }
-        ]
-      },
-      {
-        "matcher": "mcp__synapse__synapse_create_experiment|synapse_create_experiment",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-post-create-experiment.sh"
-          }
-        ]
-      }
-    ],
-    "SubagentStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-subagent-start.sh"
-          }
-        ]
-      }
-    ],
-    "SubagentStop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-subagent-stop.sh"
-          }
-        ]
-      }
-    ],
-    "TeammateIdle": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-teammate-idle.sh",
-            "async": true
-          }
-        ]
-      }
-    ],
-    "TaskCompleted": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-task-completed.sh"
-          }
-        ]
-      }
-    ],
-    "SessionEnd": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/bin/on-session-end.sh"
-          }
-        ]
-      }
-    ]
-  }
-}

package/dist/public/synapse-plugin/skills/autonomy/SKILL.md

@@ -1,177 +0,0 @@
----
-name: autonomy
-description: Drive the Claude Code-client autonomous research loop — analyze project state, propose the next experiment, dispatch sub-agents to execute it, and iterate.
-license: AGPL-3.0
-metadata:
-  author: Vincentwei1021
-  version: "0.6.1"
-  category: research
-  mcp_server: synapse
----
-
-# Autonomy Skill
-
-Use this skill when the user asks the Claude Code agent to drive research autonomously on a Synapse project: propose the next experiment, dispatch it, analyze the result, and repeat.
-
-This is the **CC-client autonomous loop**. It does not depend on the server-side `autonomousLoopEnabled` flag (that flag is for realtime-transport agents). The loop runs entirely inside the current Claude Code session: the main agent is the orchestrator, and sub-agents spawned via the Task tool are auto-enrolled by the plugin's `SubagentStart` hook.
-
-## Default Mode
-
-**Full auto** by default. When the user says "turn on autonomous loop", "run until done", or similar, assume full auto unless they say otherwise:
-
-- New experiment proposals are created as `pending_start` and immediately dispatched to sub-agents for execution.
-- The main agent does not wait for human approval between iterations.
-- The user can stop the loop at any time by interrupting the session; the main agent should also stop voluntarily once stop conditions (below) are met.
-
-If the user explicitly asks for "human review before each experiment", switch to **review mode**: proposals land as `pending_review` and the loop pauses until they are approved externally.
-
-## Full-Auto Lives In This Session Only
-
-Full-auto mode for the CC-client autonomous loop is opted in **verbally** ("turn on autonomous loop", "full auto", "run until done") and lives only in the main agent's current session context. It does **not** flip the server-side `autonomousLoopEnabled` / `autonomousLoopMode` fields, and it does not write any state to Synapse.
-
-Full-auto is a one-way track. The only exits are:
-
-- The user explicitly says stop (or interrupts the session).
-- A hard external error makes progress impossible (compute exhausted, MCP failure, network partition that cannot be recovered).
-
-Self-review **never** pauses full-auto. Sub-agent timeouts in self-review do not pause full-auto. Advisory issues raised by self-review do not pause full-auto. The main agent applies a single revision pass when feasible and continues. Whatever the main agent decides, it must be reflected in the `reviewNote` of the resulting `synapse_review_experiment` call (see template below).
-
-## Prompt Boundary
-
-Stay inside this skill when the work is about:
-- reviewing the project state after experiments finish
-- deciding whether to propose the next experiment or wait for in-flight work
-- dispatching sub-agents to execute `pending_start` experiments
-- maintaining a rolling synthesis via `synapse_save_project_synthesis`
-- detecting stop conditions and exiting cleanly
-
-Hand off to:
-- **[experiments](../experiments/SKILL.md)** for the inner execution logic of one experiment (the sub-agent operates there)
-- **[research](../research/SKILL.md)** when the loop decides it needs new literature before the next experiment
-- **[sessions](../sessions/SKILL.md)** for how sub-agent sessions and heartbeats are auto-managed
-
-## Before Starting The Loop
-
-1. `synapse_checkin()` to refresh identity and current assignments.
-2. `synapse_get_project_full_context({ researchProjectUuid })` to load brief, evaluation methods, past experiments, latest synthesis, and compute availability.
-3. Confirm with the user:
-   - target project UUID
-   - mode (`full_auto` default, or `review`)
-   - optional budgets: `maxIterations`, `maxExperimentsProposed`, `maxComputeHours`
-4. If the project has no completed experiments, do not enter the loop cold. Offer the foundational path first (data prep + baseline + eval script — see **[experiments](../experiments/SKILL.md)**), then start the loop once the baseline is in place.
-
-## Iteration Procedure
-
-Each iteration of the loop follows the same shape. The main agent runs this until a stop condition triggers.
-
-1. **Refresh project state**
-   - `synapse_get_project_full_context({ researchProjectUuid })`
-   - `synapse_get_assigned_experiments({ researchProjectUuid, statuses: ["pending_start", "in_progress"] })`
-
-2. **Decide what this iteration should do**
-   - If any experiment is `in_progress`, the loop should **monitor**, not propose. Poll `synapse_get_experiment` for each running experiment, write a progress note to the user, and yield back so the next user turn re-enters the loop.
-   - If any experiment is `pending_start` (and mode is `full_auto`), **dispatch** it: spawn a Task-tool sub-agent with the experiment UUID in its prompt. The `SubagentStart` hook auto-injects the session UUID and execution workflow; the main agent does not need to call `synapse_create_session`.
-   - If the queue is empty and there are completed experiments to digest, **synthesize** first: read the current `project_synthesis` document via `synapse_get_documents({ type: "project_synthesis" })` + `synapse_get_document`, and update it with `synapse_save_project_synthesis` only if new results add something the existing synthesis does not already cover.
-   - If the queue is empty and synthesis is current, **propose** the next experiment with `synapse_propose_experiment`. One independent run per proposal — split comparisons, ablations, and parameter sweeps into separate proposals.
-
-3. **Respect compute reality**
-   - Before proposing, check availability with `synapse_list_compute_nodes({ researchProjectUuid, onlyAvailable: true })`. Do not over-propose concurrent experiments beyond what available GPUs can run.
-   - If the project has a `computePoolUuid`, reservations must stay inside that pool.
-
-4. **Log the decision**
-   - Add a short `synapse_add_comment({ targetType: "research_project", ... })` summarizing what this iteration decided and why. This gives the human a readable audit trail in the UI.
-
-5. **Check stop conditions**, then either return control to the user (normal case) or immediately re-run step 1 if the user asked for tight, unattended iteration within a single turn.
-
-## Self-Review Before `synapse_propose_experiment`
-
-Before calling `synapse_propose_experiment`, spawn a `Task` sub-agent to self-review the proposal text (motivation, hypothesis, method, success criteria, compute fit) against the project context and evaluation methods. Self-review is in-session only — it does **not** write to Synapse. Refine the proposal text based on the verdict, then call `synapse_propose_experiment`.
-
-The same applies after `synapse_create_experiment` lands a draft inside the loop: self-review the draft via a sub-agent, revise, then push to `pending_review` and (in full-auto) auto-approve.
-
-## Monitor-Not-Executor
-
-The main agent does **not** SSH into GPU nodes, does **not** run training loops, and does **not** call `synapse_start_experiment` itself (unless the user explicitly tells it to run an experiment inline with no sub-agent). Its job is:
-
-- read state → decide → dispatch → monitor → synthesize → propose → repeat.
-
-All execution work — `synapse_start_experiment`, `synapse_get_node_access_bundle`, SSH, training, `synapse_report_experiment_progress`, `synapse_submit_experiment_results` — happens inside sub-agents. Spawn one Task sub-agent per `pending_start` experiment. Each sub-agent receives its session UUID and the full experiment workflow automatically via the `SubagentStart` hook.
-
-## Proposal Quality
-
-A good proposal includes:
-- **Motivation** — what previous result or gap this addresses
-- **Hypothesis** — what you expect to learn
-- **Method** — enough detail that a sub-agent can execute without further prompting
-- **Success criteria** — how the result will be judged against the project's evaluation method
-- **Compute fit** — realistic given current availability
-
-Bad proposals to avoid:
-- bundling multiple runs into one card
-- re-running something already completed
-- ignoring the project's stated evaluation methods
-- proposing work the available compute pool cannot support
-
-## Stop Conditions
-
-Exit the loop and report back to the user when any of these hold:
-
-- `maxIterations` reached (default: ask the user up front)
-- `maxExperimentsProposed` reached
-- `maxComputeHours` used across this loop's runs
-- synthesis has not materially changed for K consecutive iterations (no-progress detection)
-- the user interrupts or explicitly says "stop"
-- all research questions are `completed` and there is no promising direction left
-- compute pool is exhausted and no experiment is making forward progress
-
-On exit, summarize what was run, what was learned, the current state of the synthesis document, and any recommended follow-ups for a human.
-
-## Auto-Approve `reviewNote` Template (CC Full-Auto Only)
-
-When the main agent auto-approves a draft after a successful self-review:
-
-```
-synapse_review_experiment({
-  experimentUuid,
-  decision: "approved",
-  reviewNote: "Full-auto session authorized by <ownerName> at <ISO time>. Self-review pass: <key points>.",
-})
-```
-
-When self-review failed or timed out, use:
-
-```
-reviewNote: "Full-auto session authorized by <ownerName> at <ISO time>. Self-review skipped: <reason>."
-```
-
-Either way, full-auto continues — the `reviewNote` is the audit truth.
-
-## Mutual Exclusion With The Server-Side Loop
-
-If `synapse_get_research_project` shows the project already has `autonomousLoopEnabled = true` and a loop agent assigned on the realtime side, do not also run the CC-client loop against it. Warn the user and either defer, or ask them to disable the server-side loop first — running both will double-dispatch proposals and reservations.
-
-## Typical Turn
-
-```
-synapse_checkin()
-synapse_get_project_full_context({ researchProjectUuid })
-synapse_get_assigned_experiments({ researchProjectUuid, statuses: ["pending_start", "in_progress"] })
-
-# Monitor in-flight experiments if any
-# Else dispatch pending_start via Task sub-agents
-# Else synthesize if new results need analysis
-# Else propose next experiment
-
-synapse_add_comment({
-  targetType: "research_project",
-  targetUuid: "<projectUuid>",
-  content: "Iteration N — dispatched experiment <uuid> / proposed <title> / no-op (synthesis current)"
-})
-```
-
-## Reference
-
-- **[Autonomous loop reference](../synapse/references/04-autonomous-loop.md)**
-- **[Experiments skill](../experiments/SKILL.md)**
-- **[Sessions skill](../sessions/SKILL.md)**
-- **[Common tools](../synapse/references/00-common-tools.md)**

package/dist/public/synapse-plugin/skills/experiments/SKILL.md

@@ -1,135 +0,0 @@
----
-name: experiments
-description: Plan, revise, execute, and report Synapse experiments, including compute access and result submission.
-license: AGPL-3.0
-metadata:
-  author: Vincentwei1021
-  version: "0.6.1"
-  category: research
-  mcp_server: synapse
----
-
-# Experiments Skill
-
-Use this skill for the experiment stage: drafting plans, revising returned experiments, running approved work, using compute, and submitting results.
-
-## Prompt Boundary
-
-Stay inside this skill when the work is about:
-- creating a brand-new experiment from scratch
-- `draft`, `pending_review`, `pending_start`, `in_progress`, or `completed` experiments
-- plan authoring or revision based on reviewer feedback
-- reserving GPUs and starting workloads
-- reporting progress and saving results
-- writing experiment result reports
-
-Hand off to:
-- **[research](../research/SKILL.md)** for literature and deep research
-- **[autonomy](../autonomy/SKILL.md)** to drive the CC-client autonomous loop when there is nothing to execute and you need to propose the next experiment
-- **[sessions](../sessions/SKILL.md)** when running multiple experiments in parallel via sub-agents
-
-## Empty-Assignment Onboarding
-
-If `synapse_get_assigned_experiments` returns empty, do not idle. Ask the user which path:
-
-1. **Execute an approved experiment** — list `pending_start` experiments in the project with `synapse_get_project_full_context` and ask which to start.
-2. **Flesh out a quick idea** — call `synapse_get_project_full_context`, then draft a plan with `synapse_create_experiment` (defaults to `draft`; run a self-review sub-agent before pushing to `pending_review` per the "Create → Self-Review → Pending Review → Verbal Approve" section below).
-3. **Create the foundational experiment** — if the project has no completed experiments, offer the foundational template below.
-4. **Enter the autonomous loop** — hand off to **[autonomy](../autonomy/SKILL.md)** to propose and auto-dispatch the next experiment.
-
-## Create → Self-Review → Pending Review → Verbal Approve
-
-Every agent-created experiment goes through this sequence before reaching `pending_review`.
-
-1. `synapse_create_experiment(...)` — defaults to `draft`. The PostToolUse hook will remind you to run self-review next.
-2. Spawn a self-review sub-agent with the `Task` tool. Use a prompt similar to:
-   ```
-   Self-review experiment <experimentUuid> for project <projectUuid>.
-   Call synapse_get_experiment to read the plan. Then evaluate against the project's evaluationMethods:
-   - Is the objective specific and measurable?
-   - Is the methodology sound and reproducible?
-   - Do the success criteria align with the project's evaluation methods?
-   - Is the compute budget realistic given current availability (synapse_list_compute_nodes)?
-   Return a short verdict: "pass" or a bulleted list of concrete revisions.
-   Do NOT write back to Synapse — your verdict is consumed in-session by the main agent.
-   ```
-3. If the verdict surfaces issues, apply revisions with `synapse_update_experiment_plan({ experimentUuid, ... })`.
-4. `synapse_update_experiment_status({ experimentUuid, status: "pending_review" })` to push the draft into review.
-5. Present the self-review summary and the plan summary to the user in the terminal. Wait for a verbal answer.
-6. **On verbal approve:**
-   ```
-   synapse_review_experiment({
-     experimentUuid,
-     decision: "approved",
-     reviewNote: 'User verbally approved in terminal: "<exact words>"',
-   })
-   ```
-   That call atomically transitions to `pending_start`, writes the activity, and emits `task_assigned` so execution can begin.
-7. **On verbal reject:** summarize the user's revision request in second-person Chinese, including a quoted phrase from the user, and pass it as `reviewNote`:
-   ```
-   synapse_review_experiment({
-     experimentUuid,
-     decision: "rejected",
-     reviewNote: '用户口头要求修改：…（原话："…"）',
-   })
-   ```
-   The review tool writes the comment and emits `experiment_revision_requested` automatically — **do not** also call `synapse_add_comment`.
-8. After a reject, the experiment is back in `draft`. Revise per feedback, run self-review again, then resubmit to `pending_review`.
-9. **Full-auto mode** (set verbally via the `autonomy` skill, lives only in the current CC session): after step 4, skip steps 5–8 and immediately call `synapse_review_experiment` with the fixed full-auto template:
-   ```
-   reviewNote: 'Full-auto session authorized by <ownerName> at <ISO time>. Self-review pass: <key points>.'
-   ```
-   If self-review timed out or errored: `'Self-review skipped: <reason>.'`. Full-auto **never pauses** on advisory self-review output — it only exits on user-stop or hard external errors.
-
-The `synapse_review_experiment` tool requires `admin` or `pi_agent` role. To run verbal-approve flows on Claude Code, configure the CC agent with one of those roles.
-
-## Foundational First Experiment
-
-If the project has no completed experiments yet, the first experiment is not a normal research run — it is the project's baseline infrastructure. Drive it through three bundled deliverables before any comparison work:
-
-1. **Data preparation** — normalize the raw dataset into a single canonical format every future experiment will consume. Keep the prep scripts under the project's repo (if one is configured via `synapse_get_repo_access`).
-2. **Baseline run** — execute the simplest reasonable approach end-to-end and record its metrics with `synapse_submit_experiment_results`, so subsequent experiments have something to beat.
-3. **Evaluation script** — implement the canonical eval harness future experiments will call. Commit alongside data prep.
-
-If the project has a repo, commit all three onto the base branch (or a per-experiment branch merged back). Every subsequent experiment branches from that base so it inherits prep + eval automatically.
-
-## Typical Flow
-
-1. `synapse_checkin()` — refresh identity and assignments
-2. Author or fetch the experiment
-   - New plan: `synapse_create_experiment(...)` (defaults to `draft`; run a self-review sub-agent and revise before pushing to `pending_review` per the section below)
-   - Existing assignment: `synapse_get_assigned_experiments()` then `synapse_get_experiment({ experimentUuid })`
-3. If drafting or revising: `synapse_update_experiment_status({ status: "draft", liveStatus: "writing" })` + `synapse_update_experiment_plan(...)`, then `synapse_update_experiment_status({ status: "pending_review" })`
-4. Before execution: `synapse_list_compute_nodes({ onlyAvailable: true, researchProjectUuid })`
-5. Reserve compute: optional `synapse_reserve_gpus(...)` or inline via `synapse_start_experiment({ gpuUuids })`
-6. `synapse_start_experiment({ experimentUuid, workingNotes })` — moves to `in_progress`
-7. If remote compute: `synapse_get_node_access_bundle({ experimentUuid, nodeUuid })`, write the returned `privateKeyPemBase64` to a local PEM, `chmod 600`, SSH with the returned host/user/port
-8. If repo-backed: `synapse_get_repo_access` → clone → branch from the experiment's base branch (commit + push back to this repo at the end is mandatory)
-9. Run the workload in a persistent remote shell (`tmux`/`screen`) with unbuffered output (`python -u …` or `PYTHONUNBUFFERED=1`) so logs never stall a tool call
-10. Report progress with `synapse_report_experiment_progress` at milestones — `phase` ∈ `setup` | `training` | `evaluation` | `analysis`; `liveStatus` ∈ `checking_resources` | `queuing` | `running`
-11. For long runs (>30 min), schedule periodic progress updates (cron on the remote node, or the main agent polling and calling `synapse_report_experiment_progress` on a timer) so the card never looks dead
-12. Commit code/artifacts to the experiment branch or base branch; capture the commit SHA
-13. Finish with `synapse_submit_experiment_results({ outcome, experimentResults, branch, commitSha })` — `outcome` ∈ `success` | `failure` | `inconclusive`; on failure include the error and partial results
-14. **Always** follow `synapse_submit_experiment_results` with `synapse_save_experiment_report({ experimentUuid, title, content })` — write a full markdown writeup (objective, methodology, results, analysis, charts where relevant). Do **not** post the report as a comment, and do **not** treat this step as optional even for `failure` / `inconclusive` runs
-15. If revising per reviewer feedback, read the full thread first with `synapse_get_comments({ targetType: "experiment", targetUuid })` before editing the plan
-
-## Core Rules
-
-- **Never assume a server-local SSH key path exists.** Always fetch the access bundle and write the PEM locally.
-- **One independent run per experiment card.** Do not bundle comparison runs, ablations, or parameter sweeps into a single experiment — create multiple cards.
-- **Match the project description's language.** If the project brief is in Chinese, write the plan, progress, and report in Chinese.
-- **If the project is repo-backed, you must commit back.** Whenever `synapse_get_repo_access` returns a configured repo, all experiment code, configs, and meaningful artifacts must be committed and pushed to that repo (on the experiment branch or merged to base), and the resulting `branch` + `commitSha` must be passed to `synapse_submit_experiment_results`. Local-only runs without a commit are not acceptable when a repo exists.
-- **Always save an experiment report after submitting results.** Every `synapse_submit_experiment_results` call must be immediately followed by `synapse_save_experiment_report({ experimentUuid, title, content })` with a full markdown writeup. This applies to `success`, `failure`, and `inconclusive` outcomes alike.
-- **Split plan / execution / report tools.** Use `synapse_update_experiment_plan` for plan edits, `synapse_report_experiment_progress` for live status, `synapse_submit_experiment_results` for completion, and `synapse_save_experiment_report` for the dedicated report. Do not substitute with comments.
-- **Revision stays durable.** When a reviewer sends an experiment back, flip to `draft`, revise, then move it back to `pending_review`; leave a reply via `synapse_add_comment` using `@[name](actorType:uuid)` format to notify the reviewer.
-- **Failures are data.** An experiment that crashes or shows a regression is still a valid submission: set `outcome: "failure"` (or `"inconclusive"`) and write up what happened in `experimentResults` and the report.
-
-## Running Multiple Experiments In Parallel
-
-When the user wants to execute several `pending_start` experiments at the same time, the main agent should monitor and dispatch rather than run workloads itself. Spawn one Task-tool sub-agent per experiment UUID — the plugin's `SubagentStart` hook auto-creates a Synapse session and injects the full execution workflow. The main agent then polls with `synapse_get_assigned_experiments({ statuses: ["in_progress", "completed"] })` and `synapse_get_experiment` to track progress. See **[sessions](../sessions/SKILL.md)** for the full pattern.
-
-## Reference
-
-- **[Experiment workflow reference](../synapse/references/03-experiment-workflow.md)**
-- **[Common tools](../synapse/references/00-common-tools.md)**
-- **[Plugin hooks and parallel execution](../synapse/references/05-session-sub-agent.md)**

package/dist/public/synapse-plugin/skills/research/SKILL.md

@@ -1,58 +0,0 @@
----
-name: research
-description: Work on Synapse pre-experiment research: project context, research questions, literature search, related works, and deep research reports.
-license: AGPL-3.0
-metadata:
-  author: Vincentwei1021
-  version: "0.6.1"
-  category: research
-  mcp_server: synapse
----
-
-# Research Skill
-
-Use this skill for the pre-experiment stage: understanding project context, developing research questions, grounding work in literature, and producing deep research outputs.
-
-## Prompt Boundary
-
-Stay inside this skill when the work is about:
-- reading project context and framing the problem
-- creating or progressing research questions
-- searching papers and reading them progressively
-- curating `RelatedWork`
-- writing or updating a deep research report
-
-Hand off to:
-- **[experiments](../experiments/SKILL.md)** once the work becomes experiment planning or execution
-- **[autonomy](../autonomy/SKILL.md)** to drive the CC-client autonomous loop when you are choosing the next experiment yourself
-
-## Empty-Project Onboarding
-
-If `synapse_get_research_questions` and `synapse_get_related_works` both return empty for the active project, do not guess a direction. Ask the user:
-
-1. **List existing literature** — does the user already have related works elsewhere that should be imported first?
-2. **Search new literature** — run `synapse_search_papers` against an initial topic phrase supplied by the user, and curate results with `synapse_add_related_work`.
-3. **Draft a research question** — create the first `ResearchQuestion` with `synapse_create_research_question` so later experiments have a framing to attach to.
-4. **Generate a deep research report** — once some related works exist, run the progressive-read flow below and save the synthesis with `synapse_save_deep_research_report`.
-
-Offer example invocations (with the project UUID filled in) so the user can pick one. Do not skip ahead to experiment planning from this skill.
-
-## Typical Flow
-
-1. `synapse_checkin()`
-2. `synapse_get_research_project()` or `synapse_get_project_full_context()`
-3. `synapse_get_research_questions()` or create/claim a question
-4. `synapse_search_papers()` and inspect papers with `brief` / `head` / `section` / `full`
-5. `synapse_add_related_work()` for durable project memory
-6. `synapse_save_deep_research_report()` when synthesizing findings (organize thematically, not paper-by-paper; cite specific methods/results; match the project description's language)
-7. `synapse_add_comment()` on the research question or project artifacts when reasoning should be durable
-8. If the task originated from a Synapse-triggered deep research or auto search, finish with `synapse_complete_task({ taskType: "deep_research" | "auto_search" })`
-
-## Core Rule
-
-Do not drift into experiment execution from this skill. Once you are drafting a runnable experiment plan, switch to **[experiments](../experiments/SKILL.md)**.
-
-## Reference
-
-- **[Research workflow reference](../synapse/references/02-research-workflow.md)**
-- **[Common tools](../synapse/references/00-common-tools.md)**