@researai/deepscientist 1.5.15 → 1.5.17

package/src/deepscientist/bash_exec/service.py

@@ -32,6 +32,8 @@ DEFAULT_POLL_INTERVAL_SECONDS = 0.35
 TERMINAL_STATUSES = {"completed", "failed", "terminated"}
 DEFAULT_TERMINAL_SESSION_ID = "terminal-main"
 BASH_WATCHDOG_AFTER_SECONDS = 1800
+SUMMARY_RECENT_SESSION_LIMIT = 256
+SUMMARY_RUNNING_SESSION_LIMIT = 64
 INPUT_ESCAPE_SEQUENCE_RE = re.compile(r"\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b[@-_]")
 
 
@@ -373,6 +375,65 @@ class BashExecService:
             str(session.get("bash_id") or ""),
         )
 
+    @classmethod
+    def _normalize_summary_session_list(
+        cls,
+        sessions: Any,
+        *,
+        limit: int,
+    ) -> list[dict[str, Any]]:
+        max_items = max(0, int(limit or 0))
+        if max_items <= 0:
+            return []
+        normalized: dict[str, dict[str, Any]] = {}
+        for raw in sessions or []:
+            if not isinstance(raw, dict):
+                continue
+            compact = cls._summary_session_payload(raw)
+            bash_id = _normalize_string(compact.get("bash_id"))
+            if not bash_id:
+                continue
+            normalized[bash_id] = compact
+        ordered = sorted(normalized.values(), key=cls._summary_sort_key, reverse=True)
+        return ordered[:max_items]
+
+    @classmethod
+    def _merge_summary_session_list(
+        cls,
+        sessions: Any,
+        compact: dict[str, Any],
+        *,
+        limit: int,
+    ) -> list[dict[str, Any]]:
+        bash_id = _normalize_string(compact.get("bash_id"))
+        merged = cls._normalize_summary_session_list(sessions, limit=max(1, int(limit or 0)) + 1)
+        merged = [
+            item
+            for item in merged
+            if _normalize_string(item.get("bash_id")) != bash_id
+        ]
+        if bash_id:
+            merged.append(cls._summary_session_payload(compact))
+        merged.sort(key=cls._summary_sort_key, reverse=True)
+        return merged[: max(1, int(limit or 0))]
+
+    @classmethod
+    def _remove_summary_session(
+        cls,
+        sessions: Any,
+        bash_id: str,
+        *,
+        limit: int,
+    ) -> list[dict[str, Any]]:
+        normalized_bash_id = _normalize_string(bash_id)
+        if not normalized_bash_id:
+            return cls._normalize_summary_session_list(sessions, limit=limit)
+        return [
+            item
+            for item in cls._normalize_summary_session_list(sessions, limit=limit)
+            if _normalize_string(item.get("bash_id")) != normalized_bash_id
+        ][: max(1, int(limit or 0))]
+
     @staticmethod
     def _is_active_status(value: object) -> bool:
         return _coerce_session_status(value) in {"running", "terminating"}
@@ -382,9 +443,31 @@ class BashExecService:
             "session_count": 0,
             "running_count": 0,
             "latest_session": None,
+            "recent_sessions": [],
+            "running_sessions": [],
             "updated_at": utc_now(),
         }
 
+    def _normalize_summary_payload(self, summary: Any) -> dict[str, Any]:
+        merged = {**self._default_summary(), **(summary if isinstance(summary, dict) else {})}
+        latest_session = merged.get("latest_session")
+        if isinstance(latest_session, dict):
+            compact_latest = self._summary_session_payload(latest_session)
+            merged["latest_session"] = compact_latest if _normalize_string(compact_latest.get("bash_id")) else None
+        else:
+            merged["latest_session"] = None
+        merged["session_count"] = max(0, int(merged.get("session_count") or 0))
+        merged["running_count"] = max(0, int(merged.get("running_count") or 0))
+        merged["recent_sessions"] = self._normalize_summary_session_list(
+            merged.get("recent_sessions"),
+            limit=SUMMARY_RECENT_SESSION_LIMIT,
+        )
+        merged["running_sessions"] = self._normalize_summary_session_list(
+            merged.get("running_sessions"),
+            limit=SUMMARY_RUNNING_SESSION_LIMIT,
+        )
+        return merged
+
     def _refresh_summary_cache(self, quest_root: Path, summary: dict[str, Any]) -> dict[str, Any]:
         path = self.summary_path(quest_root)
         cache_key = str(path.resolve())
@@ -397,7 +480,7 @@ class BashExecService:
             )
         else:
             state = None
-        payload = dict(summary)
+        payload = self._normalize_summary_payload(summary)
         with self._summary_cache_lock:
             self._summary_cache[cache_key] = {
                 "state": state,
@@ -423,38 +506,109 @@ class BashExecService:
         summary = read_json(path, None)
         if not isinstance(summary, dict):
             return None
-        merged = {**self._default_summary(), **summary}
+        merged = self._normalize_summary_payload(summary)
         return self._refresh_summary_cache(quest_root, merged)
 
     def _write_summary(self, quest_root: Path, summary: dict[str, Any]) -> dict[str, Any]:
-        normalized = {**self._default_summary(), **summary, "updated_at": utc_now()}
+        normalized = self._normalize_summary_payload(summary)
+        normalized["updated_at"] = utc_now()
         _atomic_write_json(self.summary_path(quest_root), normalized)
         return self._refresh_summary_cache(quest_root, normalized)
 
+    def _hydrate_summary_from_index(
+        self,
+        quest_root: Path,
+        summary: dict[str, Any],
+    ) -> dict[str, Any]:
+        needs_recent_sessions = not bool(summary.get("recent_sessions"))
+        needs_running_sessions = int(summary.get("running_count") or 0) > 0 and not bool(summary.get("running_sessions"))
+        if not needs_recent_sessions and not needs_running_sessions:
+            return summary
+
+        index_path = self.index_path(quest_root)
+        if not index_path.exists():
+            return summary
+
+        candidate_ids: list[str] = []
+        seen_ids: set[str] = set()
+        max_candidates = max(SUMMARY_RECENT_SESSION_LIMIT, SUMMARY_RUNNING_SESSION_LIMIT * 4)
+        for entry in reversed(read_jsonl(index_path)):
+            bash_id = _normalize_string((entry or {}).get("bash_id") if isinstance(entry, dict) else "")
+            if not bash_id or bash_id in seen_ids:
+                continue
+            seen_ids.add(bash_id)
+            candidate_ids.append(bash_id)
+            if len(candidate_ids) >= max_candidates:
+                break
+
+        if not candidate_ids:
+            return summary
+
+        recent_sessions: list[dict[str, Any]] = []
+        running_sessions: list[dict[str, Any]] = []
+        for bash_id in candidate_ids:
+            meta = read_json(self.meta_path(quest_root, bash_id), {})
+            if not isinstance(meta, dict) or not meta:
+                continue
+            compact = self._summary_session_payload(meta)
+            recent_sessions.append(compact)
+            if self._is_active_status(meta.get("status")):
+                running_sessions.append(compact)
+
+        if not recent_sessions and not running_sessions:
+            return summary
+
+        updated_summary = dict(summary)
+        if needs_recent_sessions and recent_sessions:
+            updated_summary["recent_sessions"] = self._normalize_summary_session_list(
+                recent_sessions,
+                limit=SUMMARY_RECENT_SESSION_LIMIT,
+            )
+            if updated_summary["recent_sessions"] and not isinstance(updated_summary.get("latest_session"), dict):
+                updated_summary["latest_session"] = updated_summary["recent_sessions"][0]
+        if needs_running_sessions:
+            updated_summary["running_sessions"] = self._normalize_summary_session_list(
+                running_sessions,
+                limit=SUMMARY_RUNNING_SESSION_LIMIT,
+            )
+        return self._write_summary(quest_root, updated_summary)
+
     def _rebuild_summary(self, quest_root: Path) -> dict[str, Any]:
         summary = self._default_summary()
         latest_session: dict[str, Any] | None = None
         session_count = 0
         running_count = 0
+        recent_sessions: list[dict[str, Any]] = []
+        running_sessions: list[dict[str, Any]] = []
         for meta_path in self.sessions_root(quest_root).glob("*/meta.json"):
             meta = read_json(meta_path, {})
             if not isinstance(meta, dict) or not meta:
                 continue
             session_count += 1
+            compact = self._summary_session_payload(meta)
+            recent_sessions.append(compact)
             if self._is_active_status(meta.get("status")):
                 running_count += 1
-            compact = self._summary_session_payload(meta)
+                running_sessions.append(compact)
             if latest_session is None or self._summary_sort_key(compact) >= self._summary_sort_key(latest_session):
                 latest_session = compact
         summary["session_count"] = session_count
         summary["running_count"] = running_count
         summary["latest_session"] = latest_session
+        summary["recent_sessions"] = self._normalize_summary_session_list(
+            recent_sessions,
+            limit=SUMMARY_RECENT_SESSION_LIMIT,
+        )
+        summary["running_sessions"] = self._normalize_summary_session_list(
+            running_sessions,
+            limit=SUMMARY_RUNNING_SESSION_LIMIT,
+        )
         return self._write_summary(quest_root, summary)
 
     def summary(self, quest_root: Path) -> dict[str, Any]:
         loaded = self._load_summary_from_disk(quest_root)
         if loaded is not None:
-            return loaded
+            return self._hydrate_summary_from_index(quest_root, loaded)
         return self._rebuild_summary(quest_root)
 
     def _write_meta(self, quest_root: Path, bash_id: str, meta: dict[str, Any]) -> dict[str, Any]:
@@ -481,6 +635,23 @@ class BashExecService:
             or self._summary_sort_key(compact) >= self._summary_sort_key(latest_session)
         ):
             summary["latest_session"] = compact
+        summary["recent_sessions"] = self._merge_summary_session_list(
+            summary.get("recent_sessions"),
+            compact,
+            limit=SUMMARY_RECENT_SESSION_LIMIT,
+        )
+        if new_running:
+            summary["running_sessions"] = self._merge_summary_session_list(
+                summary.get("running_sessions"),
+                compact,
+                limit=SUMMARY_RUNNING_SESSION_LIMIT,
+            )
+        else:
+            summary["running_sessions"] = self._remove_summary_session(
+                summary.get("running_sessions"),
+                str(compact.get("bash_id") or ""),
+                limit=SUMMARY_RUNNING_SESSION_LIMIT,
+            )
         return self._write_summary(quest_root, summary)
 
     def reconcile_session(self, quest_root: Path, bash_id: str) -> dict[str, Any]:
@@ -540,10 +711,59 @@ class BashExecService:
         normalized_agent_instance_ids = {item for item in (agent_instance_ids or []) if item}
         normalized_agent_ids = {item for item in (agent_ids or []) if item}
         normalized_chat_session = _normalize_string(chat_session_id)
-        if normalized_status in {"running", "terminating"}:
-            summary = self.summary(quest_root)
-            if int(summary.get("running_count") or 0) <= 0:
-                return []
+        summary = self.summary(quest_root)
+        if normalized_status in {"running", "terminating"} and int(summary.get("running_count") or 0) <= 0:
+            return []
+        can_use_summary_fast_path = (
+            not normalized_agent_instance_ids
+            and not normalized_agent_ids
+            and not normalized_chat_session
+        )
+        if can_use_summary_fast_path:
+            candidate_compacts: list[dict[str, Any]] | None = None
+            if normalized_status in {"running", "terminating"}:
+                running_sessions = self._normalize_summary_session_list(
+                    summary.get("running_sessions"),
+                    limit=SUMMARY_RUNNING_SESSION_LIMIT,
+                )
+                filtered_running = [
+                    item
+                    for item in running_sessions
+                    if (not normalized_kind or _normalize_string(item.get("kind")).lower() == normalized_kind)
+                    and (not normalized_status or _normalize_string(item.get("status")).lower() == normalized_status)
+                ]
+                running_count = int(summary.get("running_count") or 0)
+                if len(filtered_running) >= max(1, limit) or running_count <= len(running_sessions):
+                    candidate_compacts = filtered_running
+            elif not normalized_status:
+                recent_sessions = self._normalize_summary_session_list(
+                    summary.get("recent_sessions"),
+                    limit=SUMMARY_RECENT_SESSION_LIMIT,
+                )
+                if not normalized_kind:
+                    if len(recent_sessions) >= max(1, limit) or int(summary.get("session_count") or 0) <= len(recent_sessions):
+                        candidate_compacts = recent_sessions
+                else:
+                    filtered_recent = [
+                        item
+                        for item in recent_sessions
+                        if _normalize_string(item.get("kind")).lower() == normalized_kind
+                    ]
+                    if len(filtered_recent) >= max(1, limit) or int(summary.get("session_count") or 0) <= len(recent_sessions):
+                        candidate_compacts = filtered_recent
+            if candidate_compacts is not None:
+                resolved_sessions: list[dict[str, Any]] = []
+                for compact in candidate_compacts:
+                    bash_id = _normalize_string(compact.get("bash_id"))
+                    if not bash_id:
+                        continue
+                    try:
+                        resolved_sessions.append(self.reconcile_session(quest_root, bash_id))
+                    except FileNotFoundError:
+                        continue
+                    if len(resolved_sessions) >= max(1, limit):
+                        break
+                return resolved_sessions[: max(1, limit)]
         sessions: list[dict[str, Any]] = []
         for bash_id in self._list_session_ids(quest_root):
             try:
@@ -571,6 +791,11 @@ class BashExecService:
             if self.meta_path(quest_root, normalized).exists():
                 return normalized
             raise FileNotFoundError(f"Unknown bash session `{normalized}`.")
+        summary = self.summary(quest_root)
+        latest_session = summary.get("latest_session")
+        latest_bash_id = _normalize_string((latest_session or {}).get("bash_id") if isinstance(latest_session, dict) else "")
+        if latest_bash_id and self.meta_path(quest_root, latest_bash_id).exists():
+            return latest_bash_id
         sessions = self.list_sessions(quest_root, limit=1)
         if not sessions:
             raise FileNotFoundError("No bash session found.")

package/src/deepscientist/bridges/connectors.py

@@ -1021,8 +1021,13 @@ class WeixinConnectorBridge(BaseConnectorBridge):
     @classmethod
     def _retry_delays_for_item(cls, item: dict[str, Any], exc: Exception) -> tuple[float, ...]:
         message = str(exc or "").strip().lower()
-        if "ret=-2" in message and cls._item_type(item) in {4, 5}:
+        if "ret=-2" not in message:
+            return ()
+        item_type = cls._item_type(item)
+        if item_type in {4, 5}:
             return cls._MEDIA_SEND_RETRY_DELAYS_SECONDS
+        if item_type == 1:
+            return cls._TEXT_SEND_RETRY_DELAYS_SECONDS
         return ()
 
     def _send_items(
@@ -1044,7 +1049,8 @@ class WeixinConnectorBridge(BaseConnectorBridge):
             if media_item:
                 time.sleep(self._MEDIA_SEND_INITIAL_DELAY_SECONDS)
             retry_delays: tuple[float, ...] = ()
-            for attempt in range(1 + len(self._MEDIA_SEND_RETRY_DELAYS_SECONDS)):
+            max_retries = max(len(self._TEXT_SEND_RETRY_DELAYS_SECONDS), len(self._MEDIA_SEND_RETRY_DELAYS_SECONDS))
+            for attempt in range(1 + max_retries):
                 client_id = self._next_client_id()
                 try:
                     send_weixin_message(

package/src/deepscientist/cli.py

@@ -25,23 +25,78 @@ from .registries import BaselineRegistry
 from .runners import CodexRunner, RunRequest, get_runner_factory, register_builtin_runners
 from .runtime_tools import RuntimeToolService
 from .runtime_logs import JsonlLogger
-from .shared import ensure_dir, read_yaml
+from .shared import ensure_dir, read_json, read_yaml
 from .skills import SkillInstaller
 from .tui import watch_tui
 
 
+class DeepScientistArgumentParser(argparse.ArgumentParser):
+    def error(self, message: str) -> None:
+        self.print_usage(sys.stderr)
+        self.exit(2, f"DeepScientist argument error: {message}\nRun `{self.prog} --help` for usage.\n")
+
+
 def _local_ui_url(host: str, port: int) -> str:
-    connect_host = "0.0.0.0" if host in {"0.0.0.0", "::", ""} else host
-    return f"http://{connect_host}:{port}"
+    normalized = str(host or "").strip()
+    connect_host = "127.0.0.1" if normalized in {"0.0.0.0", "::", "[::]", ""} else normalized
+    if connect_host.startswith("[") and connect_host.endswith("]"):
+        rendered_host = connect_host
+    elif ":" in connect_host:
+        rendered_host = f"[{connect_host}]"
+    else:
+        rendered_host = connect_host
+    return f"http://{rendered_host}:{port}"
+
+
+def _parse_optional_bool(value: object) -> bool | None:
+    if isinstance(value, bool):
+        return value
+    normalized = str(value or "").strip().lower()
+    if not normalized:
+        return None
+    if normalized in {"1", "true", "yes", "on"}:
+        return True
+    if normalized in {"0", "false", "no", "off"}:
+        return False
+    return None
+
+
+def _daemon_request_headers(home: Path) -> dict[str, str]:
+    headers = {"Content-Type": "application/json"}
+    state = read_json(home / "runtime" / "daemon.json", {})
+    if not isinstance(state, dict):
+        return headers
+    if bool(state.get("auth_enabled")):
+        token = str(state.get("auth_token") or "").strip()
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+def _daemon_launch_url(home: Path, *, host: str, port: int) -> str:
+    state = read_json(home / "runtime" / "daemon.json", {})
+    if isinstance(state, dict):
+        launch_url = str(state.get("launch_url") or "").strip()
+        if launch_url:
+            return launch_url
+    return _local_ui_url(host, port)
 
 
 def build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(prog="ds", description="DeepScientist Core skeleton")
+    parser = DeepScientistArgumentParser(
+        prog="ds",
+        description="DeepScientist Core skeleton",
+        allow_abbrev=False,
+    )
     parser.add_argument("--home", default=None, help="Override DeepScientist home")
     parser.add_argument("--proxy", default=None, help="Explicit outbound HTTP/WS proxy, for example `http://127.0.0.1:7890`.")
     parser.add_argument("--codex", default=None, help="Override the Codex executable path for this invocation.")
 
-    subparsers = parser.add_subparsers(dest="command", required=True)
+    subparsers = parser.add_subparsers(
+        dest="command",
+        required=True,
+        parser_class=DeepScientistArgumentParser,
+    )
 
     subparsers.add_parser("init")
 
@@ -60,12 +115,24 @@ def build_parser() -> argparse.ArgumentParser:
     daemon_parser = subparsers.add_parser("daemon")
     daemon_parser.add_argument("--host", default=None)
     daemon_parser.add_argument("--port", type=int, default=None)
+    daemon_parser.add_argument("--auth", default=None)
+    daemon_parser.add_argument("--auth-token", default=None)
+    daemon_parser.add_argument(
+        "--prompt-version",
+        default=None,
+        help="Use `latest` managed prompts, an official historical prompt version such as `1.5.13`, or an exact backup id from `.codex/prompt_versions/` for this daemon session.",
+    )
 
     run_parser = subparsers.add_parser("run")
     run_parser.add_argument("skill_id")
     run_parser.add_argument("--quest-id", required=True)
     run_parser.add_argument("--message", required=True)
     run_parser.add_argument("--model", default=None)
+    run_parser.add_argument(
+        "--prompt-version",
+        default=None,
+        help="Use `latest` managed prompts, an official historical prompt version such as `1.5.13`, or an exact backup id from `.codex/prompt_versions/` for this one-off run.",
+    )
 
     ui_parser = subparsers.add_parser("ui")
     ui_parser.add_argument("--mode", choices=("web", "tui", "both"), default="web")
@@ -186,7 +253,6 @@ def resume_command(home: Path, quest_id: str) -> int:
     print(json.dumps(snapshot, ensure_ascii=False, indent=2))
     return 0
 
-
 def _daemon_control_quest(home: Path, quest_id: str, *, action: str) -> dict | None:
     config = ConfigManager(home).load_named("config", create_optional=False)
     ui_config = config.get("ui", {})
@@ -194,7 +260,7 @@ def _daemon_control_quest(home: Path, quest_id: str, *, action: str) -> dict | N
     request = Request(
         url,
         data=json.dumps({"action": action, "source": "cli"}).encode("utf-8"),
-        headers={"Content-Type": "application/json"},
+        headers=_daemon_request_headers(home),
         method="POST",
     )
     try:
@@ -211,7 +277,7 @@ def _daemon_create_quest(home: Path, *, goal: str, quest_id: str | None) -> dict
     request = Request(
         url,
         data=json.dumps({"goal": goal, "quest_id": quest_id, "source": "cli"}).encode("utf-8"),
-        headers={"Content-Type": "application/json"},
+        headers=_daemon_request_headers(home),
         method="POST",
     )
     try:
@@ -221,18 +287,37 @@ def _daemon_create_quest(home: Path, *, goal: str, quest_id: str | None) -> dict
         return None
 
 
-def daemon_command(home: Path, host: str | None, port: int | None) -> int:
+def daemon_command(
+    home: Path,
+    host: str | None,
+    port: int | None,
+    auth: str | None,
+    auth_token: str | None,
+    prompt_version: str | None,
+) -> int:
     ensure_home_layout(home)
     config_manager = ConfigManager(home)
     config_manager.ensure_files()
     config = config_manager.load_named("config")
     ui_config = config.get("ui", {})
-    daemon = DaemonApp(home)
+    daemon = DaemonApp(
+        home,
+        browser_auth_enabled=_parse_optional_bool(auth),
+        browser_auth_token=str(auth_token or "").strip() or None,
+        prompt_version_selection=str(prompt_version or "").strip() or None,
+    )
     daemon.serve(host or ui_config.get("host", "0.0.0.0"), port or ui_config.get("port", 20999))
     return 0
 
 
-def run_command(home: Path, quest_id: str, skill_id: str, message: str, model: str | None) -> int:
+def run_command(
+    home: Path,
+    quest_id: str,
+    skill_id: str,
+    message: str,
+    model: str | None,
+    prompt_version: str | None,
+) -> int:
     ensure_home_layout(home)
     config_manager = ConfigManager(home)
     config_manager.ensure_files()
@@ -246,7 +331,11 @@ def run_command(home: Path, quest_id: str, skill_id: str, message: str, model: s
         repo_root=repo_root(),
         binary=codex_cfg.get("binary", "codex"),
         logger=logger,
-        prompt_builder=PromptBuilder(repo_root(), home),
+        prompt_builder=PromptBuilder(
+            repo_root(),
+            home,
+            prompt_version_selection=str(prompt_version or "").strip() or None,
+        ),
         artifact_service=ArtifactService(home),
     )
     register_builtin_runners(codex_runner=runner)
@@ -322,19 +411,26 @@ def launch_ink_tui(home: Path, url: str) -> int:
             )
         )
         return 1
-    return subprocess.call([node_binary, str(entry), "--base-url", url])
+    state = read_json(home / "runtime" / "daemon.json", {})
+    args = [node_binary, str(entry), "--base-url", url]
+    if isinstance(state, dict) and bool(state.get("auth_enabled")):
+        token = str(state.get("auth_token") or "").strip()
+        if token:
+            args.extend(["--auth-token", token])
+    return subprocess.call(args)
 
 
 def ui_command(home: Path, mode: str) -> int:
     config = ConfigManager(home).load_named("config", create_optional=False)
     host = config.get("ui", {}).get("host", "0.0.0.0")
     port = config.get("ui", {}).get("port", 20999)
-    url = _local_ui_url(host, port)
+    base_url = _local_ui_url(str(host), int(port))
+    launch_url = _daemon_launch_url(home, host=str(host), port=int(port))
     if mode in {"web", "both"}:
-        webbrowser.open(url)
-        print(f"Opened {url}")
+        webbrowser.open(launch_url)
+        print(f"Opened {launch_url}")
     if mode in {"tui", "both"}:
-        return launch_ink_tui(home, url)
+        return launch_ink_tui(home, base_url)
     return 0
 
 
@@ -492,9 +588,9 @@ def main(argv: list[str] | None = None) -> int:
     if args.command == "resume":
         return resume_command(home, args.quest_id)
     if args.command == "daemon":
-        return daemon_command(home, args.host, args.port)
+        return daemon_command(home, args.host, args.port, args.auth, args.auth_token, args.prompt_version)
     if args.command == "run":
-        return run_command(home, args.quest_id, args.skill_id, args.message, args.model)
+        return run_command(home, args.quest_id, args.skill_id, args.message, args.model, args.prompt_version)
     if args.command == "ui":
         return ui_command(home, args.mode)
     if args.command == "note":