@researai/deepscientist 1.5.3 → 1.5.4

package/src/deepscientist/daemon/app.py

@@ -8,12 +8,14 @@ import shutil
 import subprocess
 import threading
 import time
+from datetime import UTC, datetime, timedelta
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from typing import Any
 from urllib.parse import parse_qs, urlencode, urlparse
-from urllib.request import Request, urlopen
+from urllib.request import Request
 
+from .. import __version__
 from ..artifact import ArtifactService
 from ..bash_exec import BashExecService
 from ..bash_exec.runtime import TerminalClient
@@ -32,6 +34,7 @@ from ..connector_runtime import conversation_identity_key, format_conversation_i
 from ..config import ConfigManager
 from ..home import repo_root
 from ..memory import MemoryService
+from ..network import urlopen_with_proxy as urlopen
 from ..latex_runtime import QuestLatexService
 from ..prompts import PromptBuilder
 from ..prompts.builder import STANDARD_SKILLS
@@ -52,6 +55,13 @@ from websockets.sync.server import Server as WebSocketServer
 from websockets.sync.server import ServerConnection, serve as websocket_serve
 
 TERMINAL_STREAM_IDLE_SLEEP_SECONDS = 0.02
+CODEX_RETRY_DEFAULT_MAX_ATTEMPTS = 5
+CODEX_RETRY_DEFAULT_INITIAL_BACKOFF_SEC = 10.0
+CODEX_RETRY_DEFAULT_BACKOFF_MULTIPLIER = 6.0
+CODEX_RETRY_DEFAULT_MAX_BACKOFF_SEC = 1800.0
+LEGACY_CODEX_RETRY_INITIAL_BACKOFF_SEC = 1.0
+LEGACY_CODEX_RETRY_BACKOFF_MULTIPLIER = 2.0
+LEGACY_CODEX_RETRY_MAX_BACKOFF_SEC = 8.0
 
 
 class DaemonApp:
@@ -74,6 +84,12 @@ class DaemonApp:
         self.team_service = SingleTeamService(home)
         self.cloud_service = CloudLinkService(home)
         config = self.config_manager.load_named("config")
+        skill_config = config.get("skills") if isinstance(config.get("skills"), dict) else {}
+        self.skill_sync_summary = self.skill_installer.ensure_release_sync(
+            installed_version=__version__,
+            sync_global_enabled=bool(skill_config.get("sync_global_on_init", True)),
+            sync_existing_quests_enabled=bool(skill_config.get("sync_quest_on_open", True)),
+        )
         self.logger = JsonlLogger(home / "logs", level=config.get("logging", {}).get("level", "info"))
         self.reconciled_quests = self.quest_service.reconcile_runtime_state()
         for item in self.reconciled_quests:
@@ -633,7 +649,7 @@ class DaemonApp:
 
     def _preferred_locale(self) -> str:
         config = self.config_manager.load_named("config")
-        return str(config.get("default_locale") or "zh-CN").lower()
+        return str(config.get("default_locale") or "en-US").lower()
 
     def _polite_copy(self, *, zh: str, en: str) -> str:
         return zh if self._preferred_locale().startswith("zh") else en
@@ -1304,7 +1320,7 @@ class DaemonApp:
                 message_id=claimed_message_id,
                 run_id=run_id,
             )
-        retry_policy = self._runner_retry_policy(runner_cfg if isinstance(runner_cfg, dict) else {})
+        retry_policy = self._runner_retry_policy(runner_name, runner_cfg if isinstance(runner_cfg, dict) else {})
         max_attempts = int(retry_policy.get("max_attempts") or 1)
         turn_id = generate_id("turn")
         retry_context: dict[str, Any] | None = None
@@ -1380,7 +1396,7 @@ class DaemonApp:
                 )
                 if bool(retry_policy.get("enabled")) and attempt_index < max_attempts:
                     delay_seconds = self._retry_delay_seconds(retry_policy, attempt_index=attempt_index + 1)
-                    next_retry_at = utc_now() if delay_seconds <= 0 else None
+                    next_retry_at = self._retry_next_timestamp(delay_seconds)
                     self.quest_service.update_runtime_state(
                         quest_root=quest_root,
                         status="running",
@@ -1505,6 +1521,7 @@ class DaemonApp:
             )
             if bool(retry_policy.get("enabled")) and attempt_index < max_attempts:
                 delay_seconds = self._retry_delay_seconds(retry_policy, attempt_index=attempt_index + 1)
+                next_retry_at = self._retry_next_timestamp(delay_seconds)
                 self.quest_service.update_runtime_state(
                     quest_root=quest_root,
                     status="running",
@@ -1516,7 +1533,7 @@ class DaemonApp:
                         "max_attempts": max_attempts,
                         "last_run_id": result.run_id,
                         "last_error": failure_summary,
-                        "next_retry_at": None,
+                        "next_retry_at": next_retry_at,
                     },
                 )
                 self._append_retry_event(
@@ -1658,12 +1675,43 @@ class DaemonApp:
             return default
         return resolved if resolved >= 0 else default
 
-    def _runner_retry_policy(self, runner_cfg: dict[str, Any]) -> dict[str, Any]:
+    @staticmethod
+    def _float_matches(left: float, right: float) -> bool:
+        return abs(left - right) < 1e-9
+
+    def _runner_retry_policy(self, runner_name: str, runner_cfg: dict[str, Any]) -> dict[str, Any]:
         enabled = bool(runner_cfg.get("retry_on_failure", True))
-        max_attempts = min(5, self._coerce_positive_int(runner_cfg.get("retry_max_attempts", 5), 5))
-        initial_backoff = self._coerce_nonnegative_float(runner_cfg.get("retry_initial_backoff_sec", 1.0), 1.0)
-        multiplier = max(1.0, self._coerce_nonnegative_float(runner_cfg.get("retry_backoff_multiplier", 2.0), 2.0))
-        max_backoff = max(initial_backoff, self._coerce_nonnegative_float(runner_cfg.get("retry_max_backoff_sec", 8.0), 8.0))
+        max_attempts = min(
+            CODEX_RETRY_DEFAULT_MAX_ATTEMPTS,
+            self._coerce_positive_int(runner_cfg.get("retry_max_attempts", CODEX_RETRY_DEFAULT_MAX_ATTEMPTS), CODEX_RETRY_DEFAULT_MAX_ATTEMPTS),
+        )
+        initial_backoff = self._coerce_nonnegative_float(
+            runner_cfg.get("retry_initial_backoff_sec", CODEX_RETRY_DEFAULT_INITIAL_BACKOFF_SEC),
+            CODEX_RETRY_DEFAULT_INITIAL_BACKOFF_SEC,
+        )
+        multiplier = max(
+            1.0,
+            self._coerce_nonnegative_float(
+                runner_cfg.get("retry_backoff_multiplier", CODEX_RETRY_DEFAULT_BACKOFF_MULTIPLIER),
+                CODEX_RETRY_DEFAULT_BACKOFF_MULTIPLIER,
+            ),
+        )
+        max_backoff = max(
+            initial_backoff,
+            self._coerce_nonnegative_float(
+                runner_cfg.get("retry_max_backoff_sec", CODEX_RETRY_DEFAULT_MAX_BACKOFF_SEC),
+                CODEX_RETRY_DEFAULT_MAX_BACKOFF_SEC,
+            ),
+        )
+        if (
+            runner_name == "codex"
+            and self._float_matches(initial_backoff, LEGACY_CODEX_RETRY_INITIAL_BACKOFF_SEC)
+            and self._float_matches(multiplier, LEGACY_CODEX_RETRY_BACKOFF_MULTIPLIER)
+            and self._float_matches(max_backoff, LEGACY_CODEX_RETRY_MAX_BACKOFF_SEC)
+        ):
+            initial_backoff = CODEX_RETRY_DEFAULT_INITIAL_BACKOFF_SEC
+            multiplier = CODEX_RETRY_DEFAULT_BACKOFF_MULTIPLIER
+            max_backoff = CODEX_RETRY_DEFAULT_MAX_BACKOFF_SEC
         return {
             "enabled": enabled,
             "max_attempts": max_attempts,
@@ -1689,6 +1737,12 @@ class DaemonApp:
         delay = initial_backoff * pow(multiplier, max(0, attempt_index - 2))
         return max(0.0, min(delay, max_backoff))
 
+    @staticmethod
+    def _retry_next_timestamp(delay_seconds: float) -> str:
+        if delay_seconds <= 0:
+            return utc_now()
+        return (datetime.now(UTC) + timedelta(seconds=delay_seconds)).replace(microsecond=0).isoformat()
+
     def _wait_for_retry_delay(self, quest_id: str, delay_seconds: float) -> bool:
         if delay_seconds <= 0:
             return not self._turn_stop_requested(quest_id)
@@ -4212,6 +4266,7 @@ class DaemonApp:
                         "document_asset",
                         "terminal_restore",
                         "terminal_history",
+                        "latex_builds",
                     }:
                         payload = result(**params, path=self.path)
                     elif method == "GET":

package/src/deepscientist/network.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import os
+from urllib.parse import urlparse
+from urllib.request import ProxyHandler, Request, build_opener, urlopen as stdlib_urlopen
+
+from websockets.sync.client import connect as stdlib_websocket_connect
+
+_RUNTIME_PROXY_URL: str | None = None
+_NO_PROXY_OPENER = build_opener(ProxyHandler({}))
+_PROXY_OPENERS: dict[str, object] = {}
+
+
+def normalize_proxy_url(value: str | None) -> str | None:
+    text = str(value or "").strip()
+    return text or None
+
+
+def configure_runtime_proxy(proxy_url: str | None) -> str | None:
+    normalized = normalize_proxy_url(proxy_url)
+    global _RUNTIME_PROXY_URL
+    previous = _RUNTIME_PROXY_URL
+    _RUNTIME_PROXY_URL = normalized
+    if normalized is None:
+        if previous is not None:
+            for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"):
+                if os.environ.get(key) == previous:
+                    os.environ.pop(key, None)
+        return None
+    for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"):
+        os.environ[key] = normalized
+    # Keep local daemon traffic and loopback websocket attaches off the proxy path.
+    for key in ("NO_PROXY", "no_proxy"):
+        current = str(os.environ.get(key) or "").strip()
+        values = [item.strip() for item in current.split(",") if item.strip()]
+        for host in ("127.0.0.1", "localhost", "::1", "0.0.0.0"):
+            if host not in values:
+                values.append(host)
+        os.environ[key] = ",".join(values)
+    return normalized
+
+
+def runtime_proxy_url() -> str | None:
+    return _RUNTIME_PROXY_URL
+
+
+def should_bypass_proxy(url: str) -> bool:
+    parsed = urlparse(str(url or "").strip())
+    host = (parsed.hostname or "").strip().lower()
+    return host in {"", "127.0.0.1", "localhost", "::1", "0.0.0.0"}
+
+
+def _proxy_opener(proxy_url: str):
+    opener = _PROXY_OPENERS.get(proxy_url)
+    if opener is None:
+        opener = build_opener(ProxyHandler({"http": proxy_url, "https": proxy_url}))
+        _PROXY_OPENERS[proxy_url] = opener
+    return opener
+
+
+def urlopen_with_proxy(request: Request | str, timeout: float | None = None):
+    url = request.full_url if isinstance(request, Request) else str(request)
+    if should_bypass_proxy(url):
+        return _NO_PROXY_OPENER.open(request, timeout=timeout)
+    proxy_url = runtime_proxy_url()
+    if proxy_url:
+        return _proxy_opener(proxy_url).open(request, timeout=timeout)
+    return stdlib_urlopen(request, timeout=timeout)
+
+
+def websocket_connect_with_proxy(uri: str, /, **kwargs):
+    if should_bypass_proxy(uri):
+        kwargs.setdefault("proxy", None)
+    else:
+        proxy_url = runtime_proxy_url()
+        if proxy_url:
+            kwargs.setdefault("proxy", proxy_url)
+    return stdlib_websocket_connect(uri, **kwargs)

package/src/deepscientist/prompts/builder.py

@@ -90,7 +90,7 @@ class PromptBuilder:
         connectors_config = self.config_manager.load_named_normalized("connectors")
         quest_root = Path(snapshot["quest_root"])
         active_anchor = str(snapshot.get("active_anchor") or skill_id)
-        default_locale = str(runtime_config.get("default_locale") or "zh-CN")
+        default_locale = str(runtime_config.get("default_locale") or "en-US")
         system_block = self._prompt_fragment("src/prompts/system.md")
         connector_contract_block = self._connector_contract_block(quest_id=quest_id, snapshot=snapshot)
         sections = [
@@ -748,8 +748,12 @@ class PromptBuilder:
             "- acknowledgment_protocol: after artifact.interact returns any human message, immediately call artifact.interact(...) again to confirm receipt; if answerable, answer directly, otherwise state the short plan, nearest checkpoint, and that the current background subtask is paused",
             "- progress_protocol: emit artifact.interact(kind='progress', reply_mode='threaded', ...) at real human-meaningful checkpoints; if no natural checkpoint appears during active user-relevant work, send a concise keepalive before you drift beyond roughly 10 to 30 tool calls without a user-visible update",
             "- smoke_then_detach_protocol: for baseline reproduction, main experiments, and analysis experiments, first validate the command path with a bounded smoke test; once the smoke test passes, launch the real long run with bash_exec(mode='detach', ...) and usually leave timeout_seconds unset rather than guessing a fake deadline",
-            "- long_run_reporting_protocol: for long-running bash_exec monitoring loops, inspect real logs or status after each completed sleep/await cycle and at least once every 30 minutes at worst, then report real evidence plus the next planned check time and estimated next reply time",
+            "- progress_first_monitoring_protocol: when supervising a long-running bash_exec session, judge health by forward progress rather than by whether the final artifact has already appeared within a short window",
+            "- delta_monitoring_protocol: compare deltas such as new sample counters, new task counters, new saved files, new last_output_seq values, or changed last_progress payloads; if any of these move forward, treat the run as alive and keep observing",
+            "- long_run_reporting_protocol: for long-running bash_exec monitoring loops, inspect real logs or status after each completed sleep/await cycle and at least once every 30 minutes at worst, but only send a user-visible update when there is a human-meaningful delta or when the 30-minute visibility bound would otherwise be exceeded",
             "- long_run_watchdog_protocol: for baseline reproduction, baseline-running stages, main experiments, and other important detached runs, do not let more than 30 minutes pass without a real progress inspection and, if the run is still active, a user-visible artifact.interact progress update",
+            "- intervention_threshold_protocol: do not kill or restart a run merely because a short watch window passed without final completion; intervene only on explicit failure, clear invalidity, process exit, or no meaningful delta across a sufficiently long observation window",
+            "- slow_model_patience_protocol: if the user says the model, endpoint, or workload is expected to be slow, widen the observation window before intervention and avoid repeated no-change updates",
             "- tail_monitoring_protocol: when monitoring a detached run, prefer bash_exec(mode='read', id=..., tail_limit=..., order='desc') so you inspect the newest evidence first instead of re-reading full logs every time",
             "- managed_recovery_protocol: if a detached baseline, main-experiment, or analysis run is clearly invalid, wedged, or superseded, stop it with bash_exec(mode='kill', id=...), document the reason, fix the issue, and relaunch cleanly instead of letting a bad run linger",
             "- timeout_protocol: before using bash_exec(mode='await', ...), estimate whether the command can finish within the selected wait window; if runtime is uncertain or likely longer, use bash_exec(mode='detach', ...) and monitor, or set timeout_seconds intentionally",
@@ -764,11 +768,26 @@ class PromptBuilder:
             "- tool_call_keepalive_protocol: for active multi-step work outside long detached experiment waits, if you have spent roughly 10 to 30 tool calls without a user-visible checkpoint, send one concise artifact.interact progress update before continuing",
             "- human_progress_shape_protocol: ordinary progress updates should usually make three things explicit in human language: the current task, the main difficulty or latest real progress, and the concrete next measure you will take",
             "- eta_visibility_protocol: for baseline reproduction, main experiments, analysis experiments, and other important long-running phases, progress updates should also make the expected time to the next meaningful result, next milestone, or next user-visible update explicit; use roughly 10 to 30 minutes as the normal update window, and if the ETA is unreliable, say that and give a realistic next check-in window instead",
+            "- idea_milestone_protocol: immediately after a successful accepted artifact.submit_idea(...), send a threaded milestone that explains the idea in plain language and explicitly states whether it currently looks valid, research-worthy, and insight-bearing, plus the main risk and exact next experiment",
+            "- idea_divergence_protocol: in the idea stage, separate divergence from convergence; unless strong durable evidence already narrows the route to one obvious serious option, do not collapse onto the first plausible route before generating a small but meaningfully diverse candidate slate",
+            "- idea_lens_protocol: when idea candidates cluster around one mechanism family, deliberately switch ideation lenses such as problem-first vs solution-first, tension hunting, analogy transfer, inversion, or adjacent-possible reasoning before final selection",
+            "- idea_frontier_protocol: a temporary raw ideation slate may be larger, but after convergence the serious frontier should usually shrink back to 2 to 3 candidates and at most 5",
+            "- idea_why_now_protocol: every serious idea candidate should answer why now or what changed, not just what the mechanism is",
+            "- idea_balance_protocol: when the search space is not tiny, carry at least one conservative route and one higher-upside route into the final comparison",
+            "- idea_pitch_protocol: before artifact.submit_idea(...), make the winner pass a two-sentence pitch, a strongest-objection check, and a concrete why-now statement",
+            "- experiment_milestone_protocol: immediately after artifact.record_main_experiment(...) writes the durable result, send a threaded milestone that explains what was run, the main result, whether primary performance improved / worsened / stayed mixed versus the active baseline or best prior anchor, whether the route still looks promising, and the exact next step",
+            "- asset_grounded_analysis_protocol: before artifact.create_analysis_campaign(...), reuse current quest and user-provided assets first and only plan slices that are executable with the current assets, runtime/tooling, and available credentials",
+            "- infeasible_slice_protocol: if an analysis slice cannot actually be executed after bounded recovery, do not fake completion; record the slice with a non-success status, report the blocker explicitly, and do not pretend the system can do it",
+            "- explicit_improvement_protocol: never make the user infer performance improvement only from raw metrics; say plainly whether performance improved, worsened, or stayed mixed",
+            "- verified_reference_breadth_protocol: for paper-like writing, run broad literature search and reading, aim for roughly 30 to 50 verified references unless scope clearly justifies fewer, use one consistent citation workflow SEARCH -> VERIFY -> RETRIEVE -> VALIDATE -> ADD, use Semantic Scholar by default or Google Scholar manual search/export for discovery, use DOI/Crossref or other real metadata backfills for BibTeX and verification, Every final citation must correspond to a real paper from an actual source, store actual bibliography entries in paper/references.bib as valid BibTeX, do one explicit reference audit before bundling, and never invent citations from memory or hand-write BibTeX from scratch",
+            "- narrative_focus_protocol: for paper-like writing, organize the paper around one cohesive contribution, make What / Why / So What clear early, assume many readers judge in the order title -> abstract -> introduction -> figures, front-load value in those surfaces, use a five-part abstract formula, keep the introduction concise with 2 to 4 specific contribution bullets, and if the first sentence could be pasted into many unrelated ML papers then rewrite it until it becomes specific",
+            "- writing_reasoning_externalization_protocol: for paper-like writing, externalize major reasoning into durable notes such as paper/outline_selection.md, paper/claim_evidence_map.json, paper/related_work_map.md, paper/figure_storyboard.md, and paper/reviewer_first_pass.md; those notes should summarize current judgment, alternatives considered, evidence used, risks, and next revision action rather than hidden chain-of-thought",
+            "- outline_intro_value_protocol: for outlines and introductions, make research value explicit early and use a standard introduction arc: problem and stakes -> concrete gap/bottleneck -> remedy/core idea -> evidence preview -> contributions",
             "- teammate_voice_protocol: write like a calm capable teammate using natural first-person phrasing when helpful, for example 'I'm working on ...', 'The main issue right now is ...', 'Next I'll ...'; do not sound like a dashboard or incident log",
             "- tqdm_progress_protocol: when you control the experiment code for baseline reproduction, main experiments, or analysis experiments, instrument long loops with a throttled tqdm-style progress reporter when feasible and also prefer periodic __DS_PROGRESS__ JSON markers so monitoring stays both human-readable and machine-usable",
             "- translation_protocol: convert internal actions into user-facing meaning; describe what was finished and why it matters instead of naming every touched file, counter, timestamp, or subprocess",
             "- detail_gate_protocol: include exact counters, worker labels, timestamps, retry counts, or file names only when the user explicitly asked for them, when they change the recommended action, or when they are the only honest way to explain a real blocker",
-            "- monitoring_summary_protocol: for long-running monitoring loops, summarize the frontier state in plain language such as still progressing, temporarily stalled, recovered, or needs intervention; do not narrate each watch window unless the boundary itself matters",
+            "- monitoring_summary_protocol: for long-running monitoring loops, summarize the frontier state in plain language such as still progressing, temporarily stalled, recovered, or needs intervention; do not narrate each watch window and do not send a no-change update merely because a sleep finished unless the user-visible timing bound requires it",
             "- preflight_rewrite_protocol: before sending artifact.interact, quickly self-check whether the draft reads like a monitoring log, file inventory, or internal diary; if it mentions watch windows, heartbeats, retry counters, raw counts, timestamps, or multiple file names without being necessary for user action, rewrite it into conclusion -> meaning -> next step first",
             "- non_research_mode_protocol: if the user message looks like a non-research request, ask for a second confirmation before engaging stage skills or research workflow; after completion, leave one blocking standby interaction instead of repeatedly pinging",
             "- workspace_discipline: read and modify code inside current_workspace_root; treat quest_root as the canonical repo identity and durable runtime root",

package/src/deepscientist/quest/service.py

@@ -74,7 +74,7 @@ class QuestService:
                     if value:
                         return value.lower()
         config = ConfigManager(self.home).load_named("config")
-        return str(config.get("default_locale") or "zh-CN").lower()
+        return str(config.get("default_locale") or "en-US").lower()
 
     def localized_copy(self, *, zh: str, en: str, quest_root: Path | None = None) -> str:
         return zh if self.preferred_locale(quest_root).startswith("zh") else en

package/src/deepscientist/skills/installer.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from uuid import uuid4
 
 from ..memory.frontmatter import load_markdown_document
-from ..shared import ensure_dir
+from ..shared import ensure_dir, read_json, utc_now, write_json
 from .registry import discover_skill_bundles
 
 
@@ -63,6 +63,72 @@ class SkillInstaller:
             "notes": [],
         }
 
+    def sync_existing_quests(self) -> dict:
+        quests_root = self.home / "quests"
+        synced: list[dict[str, object]] = []
+        if not quests_root.exists():
+            return {
+                "count": 0,
+                "quests": [],
+            }
+        for quest_root in sorted(quests_root.iterdir()):
+            if not quest_root.is_dir():
+                continue
+            if not (quest_root / "quest.yaml").exists():
+                continue
+            result = self.sync_quest(quest_root)
+            synced.append(
+                {
+                    "quest_id": quest_root.name,
+                    "quest_root": str(quest_root),
+                    "codex_count": len(result.get("codex") or []),
+                    "claude_count": len(result.get("claude") or []),
+                }
+            )
+        return {
+            "count": len(synced),
+            "quests": synced,
+        }
+
+    def ensure_release_sync(
+        self,
+        *,
+        installed_version: str,
+        sync_global_enabled: bool = True,
+        sync_existing_quests_enabled: bool = True,
+        force: bool = False,
+    ) -> dict:
+        normalized_version = str(installed_version or "").strip() or "unknown"
+        state = self._read_release_sync_state()
+        previous_version = str(state.get("installed_version") or "").strip()
+        if not force and previous_version == normalized_version:
+            return {
+                "updated": False,
+                "installed_version": normalized_version,
+                "previous_version": previous_version or None,
+                "global_synced": False,
+                "existing_quests_synced": False,
+                "state_path": str(self._release_sync_state_path()),
+            }
+
+        summary: dict[str, object] = {
+            "updated": True,
+            "installed_version": normalized_version,
+            "previous_version": previous_version or None,
+            "global_synced": False,
+            "existing_quests_synced": False,
+            "state_path": str(self._release_sync_state_path()),
+            "synced_at": utc_now(),
+        }
+        if sync_global_enabled:
+            summary["global"] = self.sync_global()
+            summary["global_synced"] = True
+        if sync_existing_quests_enabled:
+            summary["existing_quests"] = self.sync_existing_quests()
+            summary["existing_quests_synced"] = True
+        self._write_release_sync_state(summary)
+        return summary
+
     def _sync_claude_projection(self, bundle, target_root: Path) -> Path:
         target = target_root / f"deepscientist-{bundle.skill_id}.md"
         if bundle.claude_md and bundle.claude_md.exists():
@@ -130,3 +196,13 @@ class SkillInstaller:
                 shutil.rmtree(target)
             else:
                 target.unlink(missing_ok=True)
+
+    def _release_sync_state_path(self) -> Path:
+        return self.home / "runtime" / "skill-sync-state.json"
+
+    def _read_release_sync_state(self) -> dict:
+        payload = read_json(self._release_sync_state_path(), {})
+        return payload if isinstance(payload, dict) else {}
+
+    def _write_release_sync_state(self, payload: dict[str, object]) -> None:
+        write_json(self._release_sync_state_path(), payload)

package/src/prompts/system.md

@@ -290,6 +290,24 @@ Use this especially for:
 - stage transitions
 - outline creation or outline selection
 - experiment launch or retry decisions
+- writing-stage reasoning notes such as outline choice, claim-evidence matching, related-work positioning, figure selection, and reviewer-first diagnosis
+
+For paper-like writing, externalize the major writing rationale into durable notes instead of leaving it only in chat:
+
+- `paper/outline_selection.md`: why this outline wins, what alternatives were rejected, and what weaknesses remain
+- `paper/claim_evidence_map.json`: which claims are supported, partially supported, or unsupported, and by what evidence
+- `paper/related_work_map.md`: nearest neighbors, comparison axes, and the exact distinction being claimed
+- `paper/figure_storyboard.md`: what each main figure/table must prove, why it belongs, and what caption message it should carry
+- `paper/reviewer_first_pass.md`: what a fast reviewer likely concludes from the first page and first decisive figure
+
+Each of those notes should read like an external reasoning memo, not hidden chain-of-thought.
+Prefer this compact shape when applicable:
+
+- current judgment
+- alternatives considered
+- evidence used
+- risks or uncertainty
+- next revision action
 - baseline acceptance or waiver
 - paper-writing decisions
 - proofing, bundle verification, and finalize readiness
@@ -340,6 +358,7 @@ Use this light heuristic:
   - the strongest currently supported line given existing experiment results, literature, and codebase constraints
 - identify a small `frontier`:
   - usually 2 to 3 plausible alternatives, not an open-ended brainstorm list
+  - a temporary raw ideation slate may be larger during one bounded divergence pass, but it should normally shrink back to 2 to 3 serious alternatives and at most 5
 - choose the `next best action`:
   - the route that most improves expected research value given what is already known
 
@@ -942,10 +961,19 @@ Prefer these patterns:
 - use `artifact.submit_idea(mode='create', lineage_intent='continue_line'|'branch_alternative', ...)` when an idea is accepted and must become the new active research head
   - treat the resulting branch as one durable research round or route, not merely a temporary Git container
   - every accepted durable idea submission should normally create a new user-visible canvas node
+  - before accepting an idea, unless strong durable evidence already narrows the route to one obvious serious option, run one bounded divergent -> convergent ideation pass instead of collapsing onto the first plausible route
+  - classify the current framing as `problem-first` or `solution-first`
+  - generate a small but genuinely diverse candidate slate before ranking, then shrink it back to a serious frontier that is usually 2 to 3 alternatives and at most 5
+  - if the candidates are all from the same mechanism family, widen once with distinct lenses such as abstraction ladder, tension hunting, analogy transfer, inversion, or adjacent-possible reasoning
+  - require each serious candidate to answer `why now` / `what changed`
+  - before `artifact.submit_idea(...)`, make the winner pass a two-sentence pitch and strongest-objection check
   - before calling it, first finish a concise but durable idea draft in Markdown that explains the route clearly enough for later implementation and review
   - when available, pass that draft through `draft_markdown` so the branch keeps both a compact `idea.md` contract and a richer `draft.md`
   - `continue_line` means the new idea is a child of the current active branch
   - `branch_alternative` means the new idea is a sibling-like branch that starts from the current branch's parent foundation
+  - immediately after a successful accepted idea submission, send `artifact.interact(kind='milestone', reply_mode='threaded', ...)`
+  - that idea milestone should tell the user, in plain language, what the idea is, whether it currently looks valid, whether it appears to have research value / novelty / real insight, the main uncertainty, and the exact next experiment or decision
+  - do not make the user infer idea quality from raw branch metadata or long prose alone; state your current judgment explicitly
 - use `artifact.submit_idea(mode='revise', ...)` only for maintenance-only in-place refinement of the same branch
   - this is compatibility-only and should not be the normal post-result research route
   - do not use `mode='revise'` as the default way to start a new optimization round, even for documentation-only changes
@@ -962,11 +990,15 @@ Prefer these patterns:
   - if comparison is invalid or evidence is limited, express that explicitly through `baseline_relation`, `comparability`, and `failure_mode` instead of hiding the uncertainty in prose
   - write it for a human reader who should understand the run outcome without opening logs, diffs, or file paths
   - keep `takeaway` to one short sentence, keep `next_action` to one best immediate route, and do not include branch ids, paths, tool traces, or raw metric dumps
+  - immediately after recording the durable main-experiment result, send `artifact.interact(kind='milestone', reply_mode='threaded', ...)`
+  - that experiment milestone should tell the user what was run, the main result, whether primary performance improved / worsened / stayed mixed versus the active baseline or best prior anchor, whether the route still looks promising, and the exact next step
+  - never force the user to infer “did performance improve?” from raw metrics alone; say it explicitly
   - once a branch has a durable main-experiment result, treat that branch as a fixed historical research node
 - use `artifact.create_analysis_campaign(...)` whenever one or more extra experiments must branch from the current workspace/result node
 - even a single extra experiment should still become a one-slice analysis campaign instead of mutating the completed parent node in place
 - use `artifact.record_analysis_slice(...)` immediately after each analysis slice finishes
   - include the same six-field `evaluation_summary` so later review, rebuttal, and route selection can read one stable summary instead of re-parsing long prose
+  - when a finished slice materially changes the route judgment, baseline comparison, or performance picture, send a user-visible `artifact.interact(...)` summary that states that impact plainly instead of leaving it buried in the slice record
 - use `artifact.prepare_branch(...)` only for compatibility or exceptional manual recovery; do not prefer it for the normal idea -> experiment -> analysis flow
 - use `artifact.confirm_baseline(...)` as the canonical baseline-stage gate after the accepted baseline root, variant, and metric contract are clear
 - use `artifact.waive_baseline(...)` only when the quest must explicitly continue without a baseline
@@ -1032,6 +1064,8 @@ For `artifact.interact(...)` specifically:
 - when a major stage deliverable is actually completed, upgrade the user-facing update to a richer `artifact.interact(kind='milestone', reply_mode='threaded', ...)` report instead of a minimal progress note
 - major stage deliverables that normally require the richer milestone report include at least: completed idea generation/selection, completed main experiment, completed analysis campaign, and completed paper/draft milestone
 - each richer milestone report should still be an external reasoning summary rather than hidden chain-of-thought, and it should normally cover: what was completed, why it matters, the key result or route impact, the main remaining risk or open question, and the exact recommended next step
+- for completed idea generation/selection, that richer milestone report should also make your current judgment explicit about whether the idea looks valid, research-worthy, and insight-bearing
+- for completed main experiments and other finished experiment records, that richer milestone report should also make explicit whether performance improved, worsened, or stayed mixed, and what evidence supports that judgment
 - that richer milestone report is still normally non-blocking: after sending it, continue the quest automatically whenever the next step is already clear from local evidence
 - if the active communication surface is QQ and the corresponding auto-send policy is enabled, a richer milestone report may include one high-value attachment such as a summary PNG or final paper PDF
 - when you explicitly request outbound media attachments through `artifact.interact(...)`, prefer one absolute-path attachment over many relative-path attachments
@@ -1108,6 +1142,10 @@ Use this exact pattern:
 Protocol rules:
 
 - even if only one extra experiment is needed, still use a one-slice campaign
+- plan the full slice list before running the first slice, and ground that list in current quest assets rather than hypothetical future resources
+- treat files, datasets, checkpoints, extracted texts, baselines, prior results, and user-provided attachments already present in the quest as the first-choice asset pool for supplementary experiments
+- do not launch slices that require unavailable assets or unsupported capabilities unless you first recover them legitimately within the current system
+- if legitimate recovery fails, report that inability explicitly and keep the missing dependency visible in the durable record rather than quietly narrowing the task
 - do not create ad-hoc follow-up branches outside this protocol unless recovery/debugging truly requires it
 - the completed parent result node is immutable history
 - for supplementary work, the canonical identity is `campaign_id + slice_id`; do not invent a separate main `run_id`
@@ -1200,6 +1238,13 @@ For analysis campaigns specifically, the safest default sequence is:
 5. call `artifact.record_analysis_slice(...)` after each slice with setup, execution, results, metrics, and a six-field `evaluation_summary`
 6. after the last slice, return automatically to the parent idea branch and continue writing
 
+Before launching or extending an analysis campaign:
+
+- start from the current quest asset pool first, especially anything the user already provided or the quest already contains, such as datasets, configs, checkpoints, extracted texts, baselines, logs, and reusable code paths
+- only launch slices that are actually executable with the current quest assets, current runtime/tooling, and currently available credentials
+- if a proposed slice depends on unavailable data, unsupported infrastructure, or capabilities the current system does not actually have, either redesign it around available assets or report plainly that the slice / campaign cannot currently be completed
+- if a slice becomes infeasible during execution, attempt bounded recovery first; if it still cannot be completed honestly, record that explicitly with a non-success status and explain the blocker instead of pretending the slice ran
+
 When writing `evaluation_summary`, use these semantics:
 
 - `takeaway`: one-sentence human-readable conclusion, starting with the outcome rather than the procedure
@@ -1686,6 +1731,17 @@ It should preserve:
   - `experimental_designs`
   - `contributions`
 
+For story quality, keep one core paper-writing discipline visible:
+
+- the paper should sell one cohesive contribution or claim cluster, not a random bag of experiments
+- force the story to answer three reader questions early and clearly:
+  - `What`: the concrete claim or contribution
+  - `Why`: the evidence that supports it
+  - `So What`: why the community should care
+- if you cannot state the contribution in one sentence, the outline is not stable yet
+- front-load value: title, abstract, introduction opening, and the first decisive figure/table should already communicate why the work matters
+- organize every major section around that core contribution with surgical focus; remove side branches that do not support the main claim
+
 When building or revising a paper-like outline, prefer the following paperagent-style requirements whenever they fit the quest:
 
 - read all relevant experiments individually before fixing the outline
@@ -1697,6 +1753,8 @@ When building or revising a paper-like outline, prefer the following paperagent-
 - prefer actual quest artifacts over older paper numbers when they conflict
 - verify that any planned figure or table can be backed by real available data
 - keep the method as the protagonist of the story without overstating what belongs to the baseline
+- make the reader-facing research value explicit early: the outline should say why the problem matters, what concrete bottleneck or gap remains, and why the current intervention changes an important evidence boundary instead of being just another variant
+- do not assume the reader will infer significance from novelty words alone; make the practical, empirical, or methodological value visible in the title / abstract / introduction plan
 
 Do not mark writing complete if critical evidence, claim mapping, proofing, or submission checks are still missing.
 If writing reveals missing evidence, route the quest back through a durable decision instead of glossing over the gap.
@@ -1704,6 +1762,16 @@ If writing reveals missing evidence, route the quest back through a durable deci
 During writing:
 
 - persist important search findings, citation notes, figure decisions, and revision notes immediately in durable files
+- before treating related work or claim framing as stable, run broad literature search and reading passes; for a normal paper-like deliverable, the default target is roughly `30` to `50` verified references unless the scope clearly justifies fewer
+- every cited paper must be real and verified from an actual source; never invent citations from memory or rely only on second-hand summaries
+- use one consistent citation workflow: `SEARCH -> VERIFY -> RETRIEVE -> VALIDATE -> ADD`
+- for search and first-pass metadata, use Semantic Scholar by default or Google Scholar via normal manual search / export only; do not rely on ad hoc random sites as the primary citation source
+- because Google Scholar has no official API, do not rely on Scholar scraping as an automated backend; use Semantic Scholar as the default programmatic search source and use DOI/Crossref, arXiv, OpenAlex, or publisher metadata as verification/backfill sources when needed
+- store actual bibliography entries in `paper/references.bib` as valid BibTeX copied or exported from Google Scholar, Semantic Scholar-linked metadata, DOI/Crossref, or publisher metadata; do not hand-write BibTeX entries from scratch
+- before `artifact.submit_paper_bundle(...)`, run one explicit reference audit for breadth, existence, and claim-level spot checks; unresolved citations keep the draft incomplete
+- for the abstract, prefer a compact five-part formula: what you achieved -> why it matters / is hard -> how you do it -> what evidence you have -> most important result
+- write the introduction in a standard research-paper shape: `problem and stakes -> concrete gap/bottleneck -> remedy / core idea -> evidence preview -> contributions`
+- keep the introduction short and high-density; for paper-style output, aim for roughly `1` to `1.5` pages, include `2` to `4` specific contribution bullets, and do not bury the methods too late when the venue style expects them earlier
 - prefer section-aware review with issue location and severity
 - re-check the introduction and claimed contributions after the experiments section stabilizes
 - run at least one explicit `5-minute reviewer pass` before calling the draft structurally sound
@@ -1866,8 +1934,12 @@ When summarizing long logs, campaigns, or multi-agent work:
   - if you need to recover or verify ids before monitoring, call `bash_exec(mode='history')` and use the reverse-chronological lines
   - after launch, monitor with explicit sleeps plus `bash_exec(mode='list')` and `bash_exec(mode='read', id=..., tail_limit=..., order='desc')`
   - after the first log read, prefer incremental checks with `bash_exec(mode='read', id=..., after_seq=last_seen_seq, tail_limit=..., order='asc')` so you only inspect newly appended evidence
+  - when supervising a long-running baseline, experiment, or analysis run, judge health by forward progress rather than by whether a final artifact has already appeared
+  - treat new sample counters, task counters, saved-result markers, output files, `last_output_seq`, and `last_progress` as the primary liveness signals
+  - if logs expose counters such as `6/46`, `99 instances`, task-completion markers, or save markers, compare those deltas first before inferring that the run is stuck
   - use `silent_seconds`, `progress_age_seconds`, `signal_age_seconds`, and `watchdog_overdue` from `bash_exec(mode='list'|'read', ...)` as the default watchdog clues instead of inferring staleness from prose alone
-  - if the run is clearly invalid, wedged, or superseded, stop it with `bash_exec(mode='kill', id=..., wait=true, timeout_seconds=...)`; if it must die immediately, add `force=true`
+  - do not restart or kill a run merely because a short observation window passed without final completion
+  - if the run is clearly invalid, wedged, superseded, or shows no meaningful delta across a sufficiently long observation window, stop it with `bash_exec(mode='kill', id=..., wait=true, timeout_seconds=...)`; if it must die immediately, add `force=true`
   - after a kill-and-wait completes, relaunch cleanly with a fresh structured `comment` rather than reusing the broken session
 - For a command that is likely to run for a long time, do not launch it and disappear. After `bash_exec(mode='detach', ...)`, keep monitoring it in the same turn through an explicit wait-and-check loop.
 - The default long-run monitoring cadence is:
@@ -1877,16 +1949,20 @@ When summarizing long logs, campaigns, or multi-agent work:
   - sleep about `600s`, then inspect again
   - sleep about `1800s`, then inspect again
   - if the run is still active, continue checking about every `1800s`
+- You may widen those windows when the user already told you that the model, endpoint, or workload is expected to be slow; prefer patience over premature intervention in that case.
 - You may monitor more frequently, but for baseline reproduction, baseline-running phases, main experiments, artifact-production phases, and other important detached work, never let more than `1800s` (30 minutes) pass without inspecting real logs or status again.
 - For those same important long-running tasks, if the run is still active after the inspection, ensure the user-visible thread also receives a concise `artifact.interact(kind='progress', ...)` update within that same `1800s` window.
 - If the only blocker is a missing user-supplied external credential that has already been requested through a blocking interaction and no other useful work is possible, you may intentionally park with a much longer low-frequency wait such as `bash_exec(command='sleep 3600', mode='await', timeout_seconds=3700, ...)` to avoid busy-looping.
 - If the environment or tool surface makes direct shell waiting awkward, an equivalent bounded wait such as `bash_exec(mode='await', id=..., timeout_seconds=...)` is acceptable, but the behavior must stay the same: wait, inspect real logs, then continue.
 - Never stay silent for more than `1800s` across an important long-running task.
-- After each sleep/await cycle finishes and you inspect the real logs again, send `artifact.interact(kind='progress', ...)` with:
+- After each sleep/await cycle finishes and you inspect the real logs again, first compare the new evidence against the last inspection.
+- If the inspection reveals a human-meaningful delta such as new samples, new completed tasks, new saved outputs, a changed `last_progress`, a route change, or a real problem, send `artifact.interact(kind='progress', ...)` with:
   - the current status
   - the latest concrete evidence from logs or outputs
+  - what changed since the previous inspection
   - the next planned check time
   - the estimated next reply time (usually the next sleep interval you are about to use)
+- If the run still looks healthy but there is no human-meaningful delta yet, continue monitoring silently instead of sending a no-change keepalive just because a sleep finished.
 - For baseline reproduction, main experiments, analysis experiments, and similar user-relevant long runs, translate that monitoring ETA into user-facing language such as how long until the next meaningful result or the next expected update.
 - Outside those detached experiment waits, if active work has already consumed roughly 10 to 30 tool calls without any user-visible checkpoint, send a concise `artifact.interact(kind='progress', ...)` before continuing.
 - If you forget a bash id, do not guess. Use `bash_exec(mode='history')` or `bash_exec(mode='list')` and recover it from the reverse-chronological session list.

package/src/skills/analysis-campaign/SKILL.md

@@ -103,10 +103,16 @@ Before launching a campaign, confirm:
 - the comparison target
 - the metric or observable of interest
 - the list of specific analysis questions
+- the current quest / user-provided assets that each planned slice will actually use
+- whether each slice is executable with the current assets, tooling, and available credentials
 - if durable state exposes `active_baseline_metric_contract_json`, read that JSON file before defining slice success criteria or comparison tables
 - treat `active_baseline_metric_contract_json` as the default baseline comparison contract unless a slice is explicitly testing a different evaluation contract
 
 If the question list is fuzzy, sharpen it before running anything.
+Treat quest files, attached user assets, checkpoints, configs, extracted texts, baselines, and existing code paths as the first-choice asset pool.
+Do not design slices around hypothetical resources that the current system cannot actually access or run.
+If a slice cannot be executed with the current system, redesign it around available assets or explicitly report that the task cannot currently be completed.
+If infeasibility appears mid-run, attempt bounded recovery first; if still blocked, record the slice with a non-success status and explain why.
 
 ## Truth sources
 
@@ -289,11 +295,13 @@ Create the campaign with `artifact.create_analysis_campaign(...)` before startin
 Even one extra experiment should still be represented as a one-slice campaign so Git and Canvas show a real child node.
 Branch that campaign from the current workspace/result node rather than mutating the completed parent node in place.
 That tool should receive the full slice list, and each returned slice worktree becomes the required execution location for that slice.
+Only create the campaign after you have verified that the listed slices are actually executable with the current quest assets and runtime.
 When the campaign is writing-facing, the same call should also carry `selected_outline_ref`, `research_questions`, `experimental_designs`, and `todo_items`.
 If ids or refs are unclear, recover them first with `artifact.resolve_runtime_refs(...)`, `artifact.get_analysis_campaign(...)`, or `artifact.list_paper_outlines(...)` instead of guessing.
 Treat `campaign_id` as system-owned, and treat `slice_id` / `todo_id` as agent-authored semantic ids.
 Do not replace the normal campaign flow with repeated manual `artifact.prepare_branch(...)` calls.
 After each slice finishes, call `artifact.record_analysis_slice(...)` immediately so the result is mirrored back to the parent branch and the next slice can be activated.
+If a slice fails or becomes infeasible, still call `artifact.record_analysis_slice(...)` with an honest non-success status plus the real blocker and next recommendation; do not leave the campaign state ambiguous.
 For slice recording, `deviations` and `evidence_paths` are optional context fields, not mandatory ceremony; include them only when they materially help explanation or auditability.
 Each `artifact.record_analysis_slice(...)` call should also include an `evaluation_summary` with exactly these six fields: