@researai/deepscientist 1.5.0 → 1.5.1

package/src/deepscientist/lingzhu_support.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import json
+import secrets
+from typing import Any
+from urllib.parse import urlparse
+
+
+DEFAULT_LINGZHU_GATEWAY_PORT = 18789
+DEFAULT_LINGZHU_LOCAL_HOST = "127.0.0.1"
+DEFAULT_LINGZHU_AGENT_ID = "main"
+DEFAULT_LINGZHU_SESSION_NAMESPACE = "lingzhu"
+
+_AUTH_AK_SEGMENTS = (8, 4, 4, 4, 12)
+_AUTH_AK_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789"
+
+
+def generate_lingzhu_auth_ak() -> str:
+    parts: list[str] = []
+    for segment_length in _AUTH_AK_SEGMENTS:
+        parts.append("".join(secrets.choice(_AUTH_AK_CHARS) for _ in range(segment_length)))
+    return "-".join(parts)
+
+
+def lingzhu_local_host(config: dict[str, Any] | None) -> str:
+    value = str((config or {}).get("local_host") or DEFAULT_LINGZHU_LOCAL_HOST).strip()
+    return value or DEFAULT_LINGZHU_LOCAL_HOST
+
+
+def lingzhu_gateway_port(config: dict[str, Any] | None) -> int:
+    raw = (config or {}).get("gateway_port")
+    try:
+        value = int(raw)
+    except (TypeError, ValueError):
+        return DEFAULT_LINGZHU_GATEWAY_PORT
+    if value < 1 or value > 65535:
+        return DEFAULT_LINGZHU_GATEWAY_PORT
+    return value
+
+
+def normalize_public_base_url(value: Any) -> str | None:
+    text = str(value or "").strip()
+    if not text:
+        return None
+    parsed = urlparse(text)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        return None
+    return text.rstrip("/")
+
+
+def lingzhu_local_base_url(config: dict[str, Any] | None) -> str:
+    return f"http://{lingzhu_local_host(config)}:{lingzhu_gateway_port(config)}"
+
+
+def lingzhu_public_base_url(config: dict[str, Any] | None) -> str | None:
+    return normalize_public_base_url((config or {}).get("public_base_url"))
+
+
+def lingzhu_health_url(config: dict[str, Any] | None, *, public: bool = False) -> str | None:
+    base = lingzhu_public_base_url(config) if public else lingzhu_local_base_url(config)
+    if not base:
+        return None
+    return f"{base}/metis/agent/api/health"
+
+
+def lingzhu_sse_url(config: dict[str, Any] | None, *, public: bool = False) -> str | None:
+    base = lingzhu_public_base_url(config) if public else lingzhu_local_base_url(config)
+    if not base:
+        return None
+    return f"{base}/metis/agent/api/sse"
+
+
+def lingzhu_agent_id(config: dict[str, Any] | None) -> str:
+    value = str((config or {}).get("agent_id") or DEFAULT_LINGZHU_AGENT_ID).strip()
+    return value or DEFAULT_LINGZHU_AGENT_ID
+
+
+def lingzhu_probe_payload(
+    config: dict[str, Any] | None,
+    *,
+    message_id: str = "ds-lingzhu-probe-001",
+    text: str = "你好",
+) -> dict[str, Any]:
+    return {
+        "message_id": message_id,
+        "agent_id": lingzhu_agent_id(config),
+        "message": [
+            {
+                "role": "user",
+                "type": "text",
+                "text": text,
+            }
+        ],
+    }
+
+
+def lingzhu_generated_openclaw_config(config: dict[str, Any] | None) -> dict[str, Any]:
+    resolved = dict(config or {})
+    return {
+        "gateway": {
+            "port": lingzhu_gateway_port(resolved),
+            "http": {
+                "endpoints": {
+                    "chatCompletions": {
+                        "enabled": True,
+                    }
+                }
+            },
+        },
+        "plugins": {
+            "entries": {
+                "lingzhu": {
+                    "enabled": bool(resolved.get("enabled", False)),
+                    "config": {
+                        "authAk": str(resolved.get("auth_ak") or "").strip(),
+                        "agentId": lingzhu_agent_id(resolved),
+                        "includeMetadata": bool(resolved.get("include_metadata", True)),
+                        "requestTimeoutMs": int(resolved.get("request_timeout_ms") or 60000),
+                        "systemPrompt": str(resolved.get("system_prompt") or ""),
+                        "defaultNavigationMode": str(resolved.get("default_navigation_mode") or "0"),
+                        "enableFollowUp": bool(resolved.get("enable_follow_up", True)),
+                        "followUpMaxCount": int(resolved.get("follow_up_max_count") or 3),
+                        "maxImageBytes": int(resolved.get("max_image_bytes") or 5 * 1024 * 1024),
+                        "sessionMode": str(resolved.get("session_mode") or "per_user"),
+                        "sessionNamespace": str(
+                            resolved.get("session_namespace") or DEFAULT_LINGZHU_SESSION_NAMESPACE
+                        ),
+                        "autoReceiptAck": bool(resolved.get("auto_receipt_ack", True)),
+                        "visibleProgressHeartbeat": bool(
+                            resolved.get("visible_progress_heartbeat", True)
+                        ),
+                        "visibleProgressHeartbeatSec": int(
+                            resolved.get("visible_progress_heartbeat_sec") or 10
+                        ),
+                        "debugLogging": bool(resolved.get("debug_logging", False)),
+                        "debugLogPayloads": bool(resolved.get("debug_log_payloads", False)),
+                        "debugLogDir": str(resolved.get("debug_log_dir") or ""),
+                        "enableExperimentalNativeActions": bool(
+                            resolved.get("enable_experimental_native_actions", False)
+                        ),
+                    },
+                }
+            }
+        },
+    }
+
+
+def lingzhu_generated_openclaw_config_text(config: dict[str, Any] | None) -> str:
+    return json.dumps(lingzhu_generated_openclaw_config(config), indent=2, ensure_ascii=False)
+
+
+def lingzhu_generated_curl(config: dict[str, Any] | None, *, text: str = "你好") -> str:
+    auth_ak = str((config or {}).get("auth_ak") or "").strip()
+    payload = lingzhu_probe_payload(config, text=text)
+    endpoint_url = lingzhu_sse_url(config) or ""
+    return (
+        f"curl -X POST '{endpoint_url}' \\\n"
+        f"  --header 'Authorization: Bearer {auth_ak}' \\\n"
+        "  --header 'Content-Type: application/json' \\\n"
+        f"  --data '{json.dumps(payload, ensure_ascii=False)}'"
+    )
+
+
+def lingzhu_supported_commands(*, experimental_enabled: bool) -> list[str]:
+    commands = [
+        "take_photo",
+        "take_navigation",
+        "control_calendar",
+        "notify_agent_off",
+    ]
+    if experimental_enabled:
+        commands.extend(
+            [
+                "send_notification",
+                "send_toast",
+                "speak_tts",
+                "start_video_record",
+                "stop_video_record",
+                "open_custom_view",
+            ]
+        )
+    return commands

package/src/deepscientist/mcp/server.py

@@ -256,6 +256,29 @@ def build_artifact_server(context: McpContext) -> FastMCP:
     def list_research_branches(comment: str | dict[str, Any] | None = None) -> dict[str, Any]:
         return service.list_research_branches(context.require_quest_root())
 
+    @server.tool(
+        name="resolve_runtime_refs",
+        description=(
+            "Resolve the current canonical research ids and refs. "
+            "Use this before supplementary work when you need the active idea, latest main run, active campaign, outline, or reply-thread ids without guessing."
+        ),
+    )
+    def resolve_runtime_refs(comment: str | dict[str, Any] | None = None) -> dict[str, Any]:
+        return service.resolve_runtime_refs(context.require_quest_root())
+
+    @server.tool(
+        name="get_analysis_campaign",
+        description=(
+            "Get one analysis campaign manifest with todo items, slice status, and next pending slice. "
+            "Pass campaign_id='active' or omit it to recover the active campaign."
+        ),
+    )
+    def get_analysis_campaign(
+        campaign_id: str | None = "active",
+        comment: str | dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return service.get_analysis_campaign(context.require_quest_root(), campaign_id=campaign_id)
+
     @server.tool(
         name="record_main_experiment",
         description=(
@@ -312,8 +335,8 @@ def build_artifact_server(context: McpContext) -> FastMCP:
     @server.tool(
         name="create_analysis_campaign",
         description=(
-            "Create a structured analysis campaign from the active idea branch. "
-            "Each slice receives its own branch/worktree and explicit requirements."
+            "Create a structured analysis campaign from the current workspace/result node. "
+            "Use this for one or more extra experiments; each slice receives its own child branch/worktree and explicit requirements."
         ),
     )
     def create_analysis_campaign(
@@ -321,6 +344,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
         campaign_goal: str,
         slices: list[dict[str, Any]],
         parent_run_id: str | None = None,
+        campaign_origin: dict[str, Any] | None = None,
         selected_outline_ref: str | None = None,
         research_questions: list[str] | None = None,
         experimental_designs: list[str] | None = None,
@@ -333,6 +357,7 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             campaign_goal=campaign_goal,
             parent_run_id=parent_run_id or context.run_id,
             slices=slices,
+            campaign_origin=campaign_origin,
             selected_outline_ref=selected_outline_ref,
             research_questions=research_questions,
             experimental_designs=experimental_designs,
@@ -371,6 +396,16 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             selected_reason=selected_reason,
         )
 
+    @server.tool(
+        name="list_paper_outlines",
+        description=(
+            "List candidate/revised paper outlines and the selected outline reference. "
+            "Use this before writing-facing analysis campaigns or when you need a valid outline_id."
+        ),
+    )
+    def list_paper_outlines(comment: str | dict[str, Any] | None = None) -> dict[str, Any]:
+        return service.list_paper_outlines(context.require_quest_root())
+
     @server.tool(
         name="submit_paper_bundle",
         description=(
@@ -421,6 +456,10 @@ def build_artifact_server(context: McpContext) -> FastMCP:
         evidence_paths: list[str] | None = None,
         metric_rows: list[dict[str, Any]] | None = None,
         deviations: list[str] | None = None,
+        claim_impact: str | None = None,
+        reviewer_resolution: str | None = None,
+        manuscript_update_hint: str | None = None,
+        next_recommendation: str | None = None,
         dataset_scope: str = "full",
         subset_approval_ref: str | None = None,
         comment: str | dict[str, Any] | None = None,
@@ -436,6 +475,10 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             evidence_paths=evidence_paths,
             metric_rows=metric_rows,
             deviations=deviations,
+            claim_impact=claim_impact,
+            reviewer_resolution=reviewer_resolution,
+            manuscript_update_hint=manuscript_update_hint,
+            next_recommendation=next_recommendation,
             dataset_scope=dataset_scope,
             subset_approval_ref=subset_approval_ref,
         )
@@ -547,6 +590,8 @@ def build_artifact_server(context: McpContext) -> FastMCP:
         expects_reply: bool | None = None,
         reply_mode: str | None = None,
         options: list[dict[str, Any]] | None = None,
+        surface_actions: list[dict[str, Any]] | None = None,
+        connector_hints: dict[str, Any] | None = None,
         allow_free_text: bool = True,
         reply_schema: dict[str, Any] | None = None,
         reply_to_interaction_id: str | None = None,
@@ -567,6 +612,8 @@ def build_artifact_server(context: McpContext) -> FastMCP:
             expects_reply=expects_reply,
             reply_mode=reply_mode,
             options=options,
+            surface_actions=surface_actions,
+            connector_hints=connector_hints,
             allow_free_text=allow_free_text,
             reply_schema=reply_schema,
             reply_to_interaction_id=reply_to_interaction_id,

package/src/deepscientist/prompts/builder.py

@@ -4,7 +4,7 @@ import json
 import re
 from pathlib import Path
 
-from ..connector_runtime import parse_conversation_id
+from ..connector_runtime import normalize_conversation_id, parse_conversation_id
 from ..config import ConfigManager
 from ..memory import MemoryService
 from ..memory.frontmatter import load_markdown_document
@@ -25,6 +25,9 @@ STANDARD_SKILLS = (
 
 COMPANION_SKILLS = (
     "figure-polish",
+    "intake-audit",
+    "review",
+    "rebuttal",
 )
 
 STAGE_MEMORY_PLAN = {
@@ -89,46 +92,57 @@ class PromptBuilder:
         active_anchor = str(snapshot.get("active_anchor") or skill_id)
         default_locale = str(runtime_config.get("default_locale") or "zh-CN")
         system_block = self._prompt_fragment("src/prompts/system.md")
-        return "\n\n".join(
+        connector_contract_block = self._connector_contract_block(quest_id=quest_id, snapshot=snapshot)
+        sections = [
+            system_block,
+            "",
+            "## Runtime Context",
+            f"ds_home: {self.home.resolve()}",
+            f"quest_id: {quest_id}",
+            f"quest_root: {quest_root}",
+            f"research_head_branch: {snapshot.get('research_head_branch') or 'none'}",
+            f"research_head_worktree_root: {snapshot.get('research_head_worktree_root') or 'none'}",
+            f"current_workspace_branch: {snapshot.get('current_workspace_branch') or 'none'}",
+            f"current_workspace_root: {snapshot.get('current_workspace_root') or 'none'}",
+            f"active_idea_id: {snapshot.get('active_idea_id') or 'none'}",
+            f"active_analysis_campaign_id: {snapshot.get('active_analysis_campaign_id') or 'none'}",
+            f"active_anchor: {active_anchor}",
+            f"active_branch: {snapshot.get('branch')}",
+            f"requested_skill: {skill_id}",
+            f"runner_name: codex",
+            f"model: {model}",
+            f"conversation_id: quest:{quest_id}",
+            f"default_locale: {default_locale}",
+            "built_in_mcp_namespaces: memory, artifact, bash_exec",
+            "mcp_namespace_note: any shell-like command execution must use bash_exec, including curl/python/bash/node and similar CLI tools; do not use transient shell snippets.",
+            "",
+            "Canonical stage skills root:",
+            str((self.repo_root / "src" / "skills").resolve()),
+            "",
+            "Standard stage skill paths:",
+            self._skill_paths_block(),
+            "",
+            "Companion skill paths:",
+            self._companion_skill_paths_block(),
+            "",
+            "## Active Communication Surface",
+            self._active_communication_surface_block(
+                quest_id=quest_id,
+                snapshot=snapshot,
+                runtime_config=runtime_config,
+                connectors_config=connectors_config,
+            ),
+        ]
+        if connector_contract_block:
+            sections.extend(
+                [
+                    "",
+                    "## Connector Contract",
+                    connector_contract_block,
+                ]
+            )
+        sections.extend(
             [
-                system_block,
-                "",
-                "## Runtime Context",
-                f"ds_home: {self.home.resolve()}",
-                f"quest_id: {quest_id}",
-                f"quest_root: {quest_root}",
-                f"research_head_branch: {snapshot.get('research_head_branch') or 'none'}",
-                f"research_head_worktree_root: {snapshot.get('research_head_worktree_root') or 'none'}",
-                f"current_workspace_branch: {snapshot.get('current_workspace_branch') or 'none'}",
-                f"current_workspace_root: {snapshot.get('current_workspace_root') or 'none'}",
-                f"active_idea_id: {snapshot.get('active_idea_id') or 'none'}",
-                f"active_analysis_campaign_id: {snapshot.get('active_analysis_campaign_id') or 'none'}",
-                f"active_anchor: {active_anchor}",
-                f"active_branch: {snapshot.get('branch')}",
-                f"requested_skill: {skill_id}",
-                f"runner_name: codex",
-                f"model: {model}",
-                f"conversation_id: quest:{quest_id}",
-                f"default_locale: {default_locale}",
-                "built_in_mcp_namespaces: memory, artifact, bash_exec",
-                "mcp_namespace_note: any shell-like command execution must use bash_exec, including curl/python/bash/node and similar CLI tools; do not use transient shell snippets.",
-                "",
-                "Canonical stage skills root:",
-                str((self.repo_root / "src" / "skills").resolve()),
-                "",
-                "Standard stage skill paths:",
-                self._skill_paths_block(),
-                "",
-                "Companion skill paths:",
-                self._companion_skill_paths_block(),
-                "",
-                "## Active Communication Surface",
-                self._active_communication_surface_block(
-                    quest_id=quest_id,
-                    snapshot=snapshot,
-                    runtime_config=runtime_config,
-                    connectors_config=connectors_config,
-                ),
                 "",
                 "## Turn Driver",
                 self._turn_driver_block(turn_reason=turn_reason, user_message=user_message),
@@ -183,7 +197,8 @@ class PromptBuilder:
                 "## Current User Message",
                 self._current_user_message_block(turn_reason=turn_reason, user_message=user_message),
             ]
-        ).strip() + "\n"
+        )
+        return "\n\n".join(sections).strip() + "\n"
 
     def _turn_driver_block(self, *, turn_reason: str, user_message: str) -> str:
         normalized_reason = str(turn_reason or "user_message").strip() or "user_message"
@@ -218,30 +233,25 @@ class PromptBuilder:
         runtime_config: dict,
         connectors_config: dict,
     ) -> str:
-        latest_user = self._latest_user_message(quest_id)
-        source = str((latest_user or {}).get("source") or "local:default").strip() or "local:default"
-        parsed = parse_conversation_id(source)
+        surface_context = self._surface_context(quest_id=quest_id, snapshot=snapshot)
+        source = surface_context["latest_user_source"]
+        surface = surface_context["active_surface"]
+        connector = surface_context["active_connector"]
+        chat_type = surface_context["active_chat_type"]
+        chat_id = surface_context["active_chat_id"]
         qq_config = connectors_config.get("qq") if isinstance(connectors_config.get("qq"), dict) else {}
 
-        if parsed is None:
-            surface = "local"
-            connector = "local"
-            chat_type = "local"
-            chat_id = "default"
-        else:
-            surface = "connector"
-            connector = str(parsed.get("connector") or "connector")
-            chat_type = str(parsed.get("chat_type") or "direct")
-            chat_id = str(parsed.get("chat_id") or "unknown")
-
         lines = [
             f"- latest_user_source: {source}",
             f"- active_surface: {surface}",
             f"- active_connector: {connector}",
             f"- active_chat_type: {chat_type}",
             f"- active_chat_id: {chat_id}",
+            f"- active_connector_origin: {surface_context['active_connector_origin']}",
+            f"- bound_external_connector_count: {surface_context['bound_external_connector_count']}",
             "- surface_rule: treat web, TUI, and connector threads as one continuous quest, but adapt the amount of detail to the active surface.",
             "- surface_reply_rule: use artifact.interact(...) for durable user-visible continuity; do not dump raw internal tool chatter into connector replies.",
+            "- connector_contract_rule: load connector-specific prompt fragments only for the active or bound external connector; do not load unused connector contracts.",
         ]
 
         if connector == "qq":
@@ -254,10 +264,12 @@ class PromptBuilder:
                     f"- qq_auto_send_analysis_summary_png: {bool(qq_config.get('auto_send_analysis_summary_png', True))}",
                     f"- qq_auto_send_slice_png: {bool(qq_config.get('auto_send_slice_png', False))}",
                     f"- qq_auto_send_paper_pdf: {bool(qq_config.get('auto_send_paper_pdf', True))}",
+                    f"- qq_enable_markdown_send: {bool(qq_config.get('enable_markdown_send', False))}",
                     f"- qq_enable_file_upload_experimental: {bool(qq_config.get('enable_file_upload_experimental', False))}",
                     "- qq_visual_rule: follow the fixed Morandi palette guide defined in the system prompt and active stage skill; do not assume per-install palette config exists.",
                     "- qq_media_rule: auto-send only high-value milestone media such as a main-experiment summary PNG, an aggregated analysis summary PNG, or the final paper PDF when available and configured.",
                     "- qq_media_rule_2: do not auto-send every slice image, every debug plot, or draft paper figures unless the user explicitly asked for them.",
+                    "- qq_structured_delivery_rule: when you want native QQ markdown or native QQ image/file delivery, request it through artifact.interact(connector_hints=..., attachments=[...]) instead of inventing connector-specific inline tag syntax.",
                 ]
             )
         else:
@@ -265,6 +277,61 @@ class PromptBuilder:
 
         return "\n".join(lines)
 
+    def _surface_context(self, *, quest_id: str, snapshot: dict) -> dict[str, str | int]:
+        latest_user = self._latest_user_message(quest_id)
+        latest_user_source = str((latest_user or {}).get("source") or "local:default").strip() or "local:default"
+        latest_user_parsed = parse_conversation_id(normalize_conversation_id(latest_user_source))
+        bound_sources = snapshot.get("bound_conversations") or []
+        bound_external: list[dict[str, str]] = []
+        for raw in bound_sources:
+            parsed = parse_conversation_id(normalize_conversation_id(raw))
+            if parsed is None:
+                continue
+            if str(parsed.get("connector") or "").strip().lower() == "local":
+                continue
+            bound_external.append(parsed)
+        active = bound_external[0] if bound_external else None
+        origin = "bound_external_binding" if active is not None else "latest_user_source"
+        if active is None and latest_user_parsed is not None:
+            latest_connector = str(latest_user_parsed.get("connector") or "").strip().lower()
+            if latest_connector and latest_connector != "local":
+                active = latest_user_parsed
+        if active is None:
+            return {
+                "latest_user_source": latest_user_source,
+                "active_surface": "local",
+                "active_connector": "local",
+                "active_chat_type": "local",
+                "active_chat_id": "default",
+                "active_connector_origin": "none",
+                "bound_external_connector_count": len(bound_external),
+            }
+        return {
+            "latest_user_source": latest_user_source,
+            "active_surface": "connector",
+            "active_connector": str(active.get("connector") or "connector"),
+            "active_chat_type": str(active.get("chat_type") or "direct"),
+            "active_chat_id": str(active.get("chat_id") or "unknown"),
+            "active_connector_origin": origin,
+            "bound_external_connector_count": len(bound_external),
+        }
+
+    def _active_external_connector_name(self, *, quest_id: str, snapshot: dict) -> str | None:
+        surface_context = self._surface_context(quest_id=quest_id, snapshot=snapshot)
+        connector = str(surface_context.get("active_connector") or "").strip().lower()
+        if not connector or connector == "local":
+            return None
+        return connector
+
+    def _connector_contract_block(self, *, quest_id: str, snapshot: dict) -> str:
+        connector = self._active_external_connector_name(quest_id=quest_id, snapshot=snapshot)
+        if connector is None:
+            return ""
+        path = self.repo_root / "src" / "prompts" / "connectors" / f"{connector}.md"
+        if not path.exists():
+            return ""
+        return self._markdown_body(path)
+
     def _active_user_requirements_block(self, quest_root: Path) -> str:
         path = self.quest_service._active_user_requirements_path(quest_root)
         if not path.exists():
@@ -563,10 +630,32 @@ class PromptBuilder:
                 return value
         return "user_gated"
 
+    @staticmethod
+    def _launch_mode(snapshot: dict) -> str:
+        startup_contract = snapshot.get("startup_contract")
+        if isinstance(startup_contract, dict):
+            value = str(startup_contract.get("launch_mode") or "").strip().lower()
+            if value in {"standard", "custom"}:
+                return value
+        return "standard"
+
+    @staticmethod
+    def _custom_profile(snapshot: dict) -> str:
+        startup_contract = snapshot.get("startup_contract")
+        if isinstance(startup_contract, dict):
+            value = str(startup_contract.get("custom_profile") or "").strip().lower()
+            if value in {"continue_existing_state", "revision_rebuttal", "freeform"}:
+                return value
+        return "freeform"
+
     def _research_delivery_policy_block(self, snapshot: dict) -> str:
         need_research_paper = self._need_research_paper(snapshot)
+        launch_mode = self._launch_mode(snapshot)
+        custom_profile = self._custom_profile(snapshot)
         lines = [
             f"- need_research_paper: {need_research_paper}",
+            f"- launch_mode: {launch_mode}",
+            f"- custom_profile: {custom_profile if launch_mode == 'custom' else 'n/a'}",
             f"- delivery_mode: {'paper_required' if need_research_paper else 'algorithm_first'}",
             "- idea_stage_rule: every accepted idea submission should normally create a new branch/worktree and a new user-visible research node.",
             "- idea_draft_rule: before `artifact.submit_idea(...)`, first finish a concise durable Markdown draft for the chosen route; keep `idea.md` compact and `draft.md` richer.",
@@ -575,12 +664,40 @@ class PromptBuilder:
             "- post_main_result_rule: after every `artifact.record_main_experiment(...)`, first interpret the measured result and only then choose the next route.",
             "- foundation_selection_rule: for a genuinely new idea round, default to the current research head but feel free to choose another durable foundation when it is cleaner or stronger; inspect `artifact.list_research_branches(...)` first when the best foundation is not obvious.",
         ]
+        if launch_mode == "custom":
+            lines.extend(
+                [
+                    "- custom_launch_rule: do not force the canonical full-research path when the custom startup contract is narrower.",
+                    "- custom_context_rule: treat `entry_state_summary`, `review_summary`, and `custom_brief` as active runtime context rather than decorative metadata.",
+                ]
+            )
+            if custom_profile == "continue_existing_state":
+                lines.extend(
+                    [
+                        "- existing_state_entry_rule: if reusable baselines, runs, drafts, or review assets already exist, open `intake-audit` before restarting baseline discovery or new experiments.",
+                        "- reuse_first_rule: trust-rank and reconcile existing assets before deciding to rerun anything costly.",
+                    ]
+                )
+            elif custom_profile == "revision_rebuttal":
+                lines.extend(
+                    [
+                        "- rebuttal_entry_rule: treat reviewer comments and the current paper state as the active contract; open `rebuttal` before ordinary writing.",
+                        "- rebuttal_routing_rule: route supplementary reviewer-facing evidence through `analysis-campaign` and manuscript deltas through `write`, but let `rebuttal` orchestrate that mapping.",
+                    ]
+                )
+            else:
+                lines.extend(
+                    [
+                        "- freeform_entry_rule: prefer the custom brief over the default stage order and open only the skills actually needed.",
+                    ]
+                )
         if need_research_paper:
             lines.extend(
                 [
                     "- delivery_goal: the quest should normally continue until at least one paper-like deliverable exists.",
                     "- main_result_rule: a strong main experiment is evidence, not the endpoint; usually continue into the necessary analysis, writing, or further strengthening work.",
                     "- writing_rule: when the evidence becomes strong enough, analysis and paper writing remain in scope by default.",
+                    "- review_gate_rule: before declaring a substantial paper/draft task done, open `review` for an independent skeptical audit; if that audit finds serious gaps, route to `analysis-campaign`, `baseline`, `scout`, or `write` instead of stopping.",
                     "- stop_rule: do not stop with only an improved algorithm or isolated run logs unless the user explicitly narrows scope.",
                 ]
             )
@@ -602,21 +719,27 @@ class PromptBuilder:
         bound_conversations = snapshot.get("bound_conversations") or []
         need_research_paper = self._need_research_paper(snapshot)
         decision_policy = self._decision_policy(snapshot)
+        launch_mode = self._launch_mode(snapshot)
+        custom_profile = self._custom_profile(snapshot)
         lines = [
             f"- configured_default_locale: {default_locale}",
             f"- current_turn_language_bias: {'zh' if chinese_turn else 'en'}",
             f"- bound_conversation_count: {len(bound_conversations)}",
             f"- decision_policy: {decision_policy}",
+            f"- launch_mode: {launch_mode}",
+            f"- custom_profile: {custom_profile if launch_mode == 'custom' else 'n/a'}",
             "- collaboration_mode: long-horizon, continuity-first, artifact-aware",
-            "- response_pattern: acknowledge current state -> state the next action -> mention the artifact/file/checkpoint that will change",
+            "- response_pattern: say what changed -> say what it means -> say what happens next",
             "- interaction_protocol: first message may be plain conversation; after that, treat artifact.interact threads and mailbox polls as the main continuity spine across TUI, web, and connectors",
             "- mailbox_protocol: artifact.interact(include_recent_inbound_messages=True) is the queued human-message mailbox; when it returns user text, treat that input as higher priority than background subtasks until it has been acknowledged",
             "- 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 each real checkpoint and usually every 3-8 tool calls during active work; also poll before another multi-step batch or long bash_exec launch; keep updates high-signal and never filler",
+            "- progress_protocol: emit artifact.interact(kind='progress', reply_mode='threaded', ...) only at real human-meaningful checkpoints, after the first meaningful signal from long-running work, and then only occasional keepalives during truly long work, usually about every 20 to 30 minutes",
             "- long_run_reporting_protocol: for long-running bash_exec monitoring loops, report after each completed sleep/await cycle with real evidence plus the next planned check time and estimated next reply time",
             "- blocking_protocol: use reply_mode='blocking' only for true unresolved user decisions; ordinary progress updates should stay threaded and non-blocking",
+            f"- standby_prefix_rule: when you intentionally leave one blocking standby interaction after task completion, prefix it with {'[等待决策]' if chinese_turn else '[Waiting for decision]'} and wait for a new user reply before continuing",
             "- stop_notice_protocol: if work must pause or stop, send a user-visible notice that explains why, confirms preserved context, and states that any new message or `/resume` will continue from the same quest",
-            "- respect_protocol: write user-facing updates as respectful, human, supervisor-style reports; templates are references only and must be adapted to context (do not copy/paste the same template repeatedly)",
+            "- respect_protocol: write user-facing updates as natural, respectful, easy-to-follow chat; do not sound like a formal status report or internal tool log",
+            "- omission_protocol: for ordinary user-facing updates, omit file paths, artifact ids, branch/worktree ids, session ids, raw commands, raw logs, and internal tool names unless the user asked for them or needs them to act",
             "- 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",
             "- binary_safety: do not open or rewrite large binary assets unless truly necessary; prefer summaries, metadata, and targeted inspection first",

package/src/deepscientist/quest/layout.py

@@ -21,6 +21,7 @@ QUEST_DIRECTORIES = (
     "experiments/main",
     "handoffs",
     "literature",
+    "userfiles",
     "tmp",
     "memory/decisions",
     "memory/episodes",