@researai/deepscientist 1.5.7 → 1.5.8

package/src/deepscientist/bash_exec/monitor.py

@@ -448,7 +448,7 @@ def run_monitor(session_dir: Path) -> int:
                 _terminate_process(process, process_group_id)
                 stop_requested = True
 
-            if session_kind == "terminal" and output_fd is not None and process.poll() is None:
+            if output_fd is not None and process.poll() is None:
                 cursor_payload = read_json(input_cursor_path, {}) or {}
                 offset = int(cursor_payload.get("offset") or 0)
                 input_entries = read_jsonl(input_path)

package/src/deepscientist/bash_exec/service.py

@@ -555,6 +555,7 @@ class BashExecService:
         before_seq: int | None = None,
         after_seq: int | None = None,
         order: str = "asc",
+        prefer_visible: bool = False,
     ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
         if not self.meta_path(quest_root, bash_id).exists():
             raise FileNotFoundError(f"Unknown bash session `{bash_id}`.")
@@ -579,9 +580,16 @@ class BashExecService:
             entries = [entry for entry in entries if int(entry.get("seq") or 0) > normalized_after]
         if normalized_before is not None:
             entries = [entry for entry in entries if int(entry.get("seq") or 0) < normalized_before]
+        selection_pool = entries
+        if prefer_visible:
+            visible_entries = [
+                entry for entry in entries if str(entry.get("stream") or "") not in {"system", "prompt"}
+            ]
+            if visible_entries:
+                selection_pool = visible_entries
         normalized_limit = max(1, limit)
-        truncated = len(entries) > normalized_limit
-        selected = entries[-normalized_limit:]
+        truncated = len(selection_pool) > normalized_limit
+        selected = selection_pool[-normalized_limit:]
         if order == "desc":
             selected = list(reversed(selected))
         tail_start_seq = int(selected[0].get("seq") or 0) if selected else None
@@ -1025,15 +1033,14 @@ class BashExecService:
         if not normalized_data:
             raise ValueError("terminal_input_required")
         session = self.reconcile_session(quest_root, bash_id)
-        if _normalize_string(session.get("kind")).lower() != "terminal":
-            raise ValueError("not_terminal_session")
         status = _normalize_string(session.get("status")).lower()
         if status in TERMINAL_STATUSES:
             raise ValueError("terminal_session_inactive")
         runtime = self._terminal_runtime_manager.get_runtime(quest_root, bash_id)
-        if runtime is None:
+        if runtime is None and _normalize_string(session.get("kind")).lower() == "terminal":
             raise ValueError("terminal_runtime_inactive")
-        runtime.write_input(normalized_data)
+        if runtime is not None:
+            runtime.write_input(normalized_data)
 
         entry = {
             "input_id": generate_id("tin"),
@@ -1081,9 +1088,10 @@ class BashExecService:
         return True
 
     def issue_terminal_attach_token(self, quest_root: Path, bash_id: str, *, ttl_seconds: int = 60) -> dict[str, Any]:
-        runtime = self._terminal_runtime_manager.get_runtime(quest_root, bash_id)
-        if runtime is None:
-            raise ValueError("terminal_runtime_inactive")
+        session = self.reconcile_session(quest_root, bash_id)
+        status = _normalize_string(session.get("status")).lower()
+        if status in TERMINAL_STATUSES:
+            raise ValueError("terminal_session_inactive")
         token = self._terminal_runtime_manager.issue_attach_token(
             quest_root,
             bash_id,

package/src/deepscientist/channels/qq.py

@@ -293,6 +293,20 @@ class QQRelayChannel(BaseChannel):
         def matches_profile(item: dict[str, Any], profile_id: str) -> bool:
             item_profile_id = str(item.get("profile_id") or "").strip()
             return item_profile_id == profile_id or (not item_profile_id and len(profiles) == 1)
+
+        def count_profile_records(path: Path, profile_id: str) -> int:
+            total = 0
+            for raw in read_jsonl(path):
+                if not isinstance(raw, dict):
+                    continue
+                record_profile_id = str(raw.get("profile_id") or "").strip()
+                if not record_profile_id:
+                    parsed = parse_conversation_id(str(raw.get("conversation_id") or "").strip())
+                    record_profile_id = str((parsed or {}).get("profile_id") or "").strip()
+                if record_profile_id == profile_id or (not record_profile_id and len(profiles) == 1):
+                    total += 1
+            return total
+
         profile_snapshots = []
         for profile in profiles:
             profile_id = str(profile.get("profile_id") or "").strip()
@@ -342,6 +356,9 @@ class QQRelayChannel(BaseChannel):
                     "discovered_targets": profile_targets,
                     "recent_conversations": profile_recent_conversations,
                     "bindings": profile_bindings,
+                    "inbox_count": count_profile_records(self.inbox_path, profile_id),
+                    "outbox_count": count_profile_records(self.outbox_path, profile_id),
+                    "ignored_count": count_profile_records(self.ignored_path, profile_id),
                     "target_count": len(profile_targets),
                     "binding_count": len(profile_bindings),
                     "last_error": gateway_state.get("last_error") if isinstance(gateway_state, dict) else None,

package/src/deepscientist/channels/relay.py

@@ -282,6 +282,19 @@ class GenericRelayChannel(BaseChannel):
             item_profile_id = str(item.get("profile_id") or "").strip()
             return item_profile_id == profile_id or (not item_profile_id and len(profiles) == 1)
 
+        def count_profile_records(path: Path, profile_id: str) -> int:
+            total = 0
+            for raw in read_jsonl(path):
+                if not isinstance(raw, dict):
+                    continue
+                record_profile_id = str(raw.get("profile_id") or "").strip()
+                if not record_profile_id:
+                    parsed = parse_conversation_id(str(raw.get("conversation_id") or "").strip())
+                    record_profile_id = str((parsed or {}).get("profile_id") or "").strip()
+                if record_profile_id == profile_id or (not record_profile_id and len(profiles) == 1):
+                    total += 1
+            return total
+
         profile_snapshots = []
         for profile in profiles:
             profile_id = str(profile.get("profile_id") or "").strip()
@@ -322,6 +335,9 @@ class GenericRelayChannel(BaseChannel):
                     "discovered_targets": profile_targets,
                     "recent_conversations": profile_recent_conversations,
                     "bindings": profile_bindings,
+                    "inbox_count": count_profile_records(self.inbox_path, profile_id),
+                    "outbox_count": count_profile_records(self.outbox_path, profile_id),
+                    "ignored_count": count_profile_records(self.ignored_path, profile_id),
                     "target_count": len(profile_targets),
                     "binding_count": len(profile_bindings),
                     "last_error": profile_runtime_state.get("last_error") if isinstance(profile_runtime_state, dict) else None,

package/src/deepscientist/config/models.py

@@ -6,6 +6,7 @@ from pathlib import Path
 CONFIG_NAMES = ("config", "runners", "connectors", "plugins", "mcp_servers")
 REQUIRED_CONFIG_NAMES = ("config", "runners", "connectors")
 OPTIONAL_CONFIG_NAMES = ("plugins", "mcp_servers")
+SYSTEM_CONNECTOR_NAMES = ("qq", "telegram", "discord", "slack", "feishu", "whatsapp", "lingzhu")
 
 
 @dataclass(frozen=True)
@@ -20,6 +21,10 @@ def config_filename(name: str) -> str:
     return f"{name}.yaml"
 
 
+def default_system_enabled_connectors() -> dict[str, bool]:
+    return {name: name == "qq" for name in SYSTEM_CONNECTOR_NAMES}
+
+
 def default_config(home: Path) -> dict:
     return {
         "home": str(home),
@@ -65,6 +70,7 @@ def default_config(home: Path) -> dict:
             "auto_ack": True,
             "milestone_push": True,
             "direct_chat_enabled": True,
+            "system_enabled": default_system_enabled_connectors(),
         },
         "cloud": {
             "enabled": False,

package/src/deepscientist/config/service.py

@@ -37,6 +37,7 @@ from .models import (
     OPTIONAL_CONFIG_NAMES,
     REQUIRED_CONFIG_NAMES,
     ConfigFileInfo,
+    SYSTEM_CONNECTOR_NAMES,
     config_filename,
     default_payload,
 )
@@ -95,6 +96,33 @@ class ConfigManager:
     def load_runners_config(self) -> dict:
         return apply_runners_runtime_overrides(self.load_named_normalized("runners"))
 
+    def load_runtime_config(self) -> dict:
+        return self.load_named_normalized("config")
+
+    def system_connector_gates(self) -> dict[str, bool]:
+        config = self.load_runtime_config()
+        connectors = config.get("connectors") if isinstance(config.get("connectors"), dict) else {}
+        system_enabled = connectors.get("system_enabled") if isinstance(connectors.get("system_enabled"), dict) else {}
+        return {
+            name: self._coerce_bool(system_enabled.get(name), default=name == "qq")
+            for name in SYSTEM_CONNECTOR_NAMES
+        }
+
+    def system_enabled_connector_names(self) -> list[str]:
+        gates = self.system_connector_gates()
+        return [name for name in SYSTEM_CONNECTOR_NAMES if gates.get(name, False)]
+
+    def is_connector_system_enabled(self, name: str) -> bool:
+        normalized = str(name or "").strip().lower()
+        if not normalized:
+            return False
+        if normalized == "local":
+            return True
+        gates = self.system_connector_gates()
+        if normalized in gates:
+            return gates[normalized]
+        return True
+
     def load_named_text(self, name: str, create_optional: bool = False) -> str:
         path = self.path_for(name)
         if create_optional and name in OPTIONAL_CONFIG_NAMES and not path.exists():
@@ -1047,6 +1075,12 @@ Use **Test** when the file exposes runtime dependencies.
         checked_at = utc_now()
         binary = str(config.get("binary") or "codex").strip() or "codex"
         resolved_binary = resolve_runner_binary(binary, runner_name="codex")
+        raw_reasoning_effort = config.get("model_reasoning_effort")
+        reasoning_effort = (
+            str(raw_reasoning_effort).strip()
+            if raw_reasoning_effort is not None and str(raw_reasoning_effort).strip()
+            else ("xhigh" if raw_reasoning_effort is None else None)
+        )
         details: dict[str, object] = {
             "binary": binary,
             "resolved_binary": resolved_binary,
@@ -1054,7 +1088,7 @@ Use **Test** when the file exposes runtime dependencies.
             "model": str(config.get("model") or "gpt-5.4"),
             "approval_policy": str(config.get("approval_policy") or "on-request"),
             "sandbox_mode": str(config.get("sandbox_mode") or "workspace-write"),
-            "reasoning_effort": str(config.get("model_reasoning_effort") or "xhigh"),
+            "reasoning_effort": reasoning_effort,
             "checked_at": checked_at,
         }
         if not resolved_binary:
@@ -1087,7 +1121,6 @@ Use **Test** when the file exposes runtime dependencies.
         approval_policy = str(config.get("approval_policy") or "on-request").strip()
         if approval_policy:
             command.extend(["-c", f'approval_policy="{approval_policy}"'])
-        reasoning_effort = str(config.get("model_reasoning_effort") or "xhigh").strip()
         if reasoning_effort:
             command.extend(["-c", f'model_reasoning_effort="{reasoning_effort}"'])
         sandbox_mode = str(config.get("sandbox_mode") or "workspace-write").strip()
@@ -1378,6 +1411,8 @@ Use **Test** when the file exposes runtime dependencies.
         normalized = self._deep_merge(defaults, payload)
         bootstrap = normalized.get("bootstrap") if isinstance(normalized.get("bootstrap"), dict) else {}
         raw_bootstrap = payload.get("bootstrap") if isinstance(payload.get("bootstrap"), dict) else {}
+        connectors = normalized.get("connectors") if isinstance(normalized.get("connectors"), dict) else {}
+        raw_connectors = payload.get("connectors") if isinstance(payload.get("connectors"), dict) else {}
         default_locale = str(defaults.get("default_locale") or "").strip()
         current_locale = str(normalized.get("default_locale") or "").strip()
         locale_source = str(raw_bootstrap.get("locale_source") or "").strip().lower()
@@ -1401,6 +1436,25 @@ Use **Test** when the file exposes runtime dependencies.
         bootstrap["locale_initialized_at"] = bootstrap.get("locale_initialized_at")
         bootstrap["locale_initialized_browser_locale"] = bootstrap.get("locale_initialized_browser_locale")
         normalized["bootstrap"] = bootstrap
+        raw_system_enabled = raw_connectors.get("system_enabled") if isinstance(raw_connectors.get("system_enabled"), dict) else {}
+        default_system_enabled = (
+            defaults.get("connectors", {}).get("system_enabled")
+            if isinstance(defaults.get("connectors"), dict)
+            else {}
+        )
+        current_system_enabled = (
+            connectors.get("system_enabled")
+            if isinstance(connectors.get("system_enabled"), dict)
+            else {}
+        )
+        connectors["system_enabled"] = {
+            name: self._coerce_bool(
+                raw_system_enabled.get(name, current_system_enabled.get(name)),
+                default=bool(default_system_enabled.get(name, False)),
+            )
+            for name in SYSTEM_CONNECTOR_NAMES
+        }
+        normalized["connectors"] = connectors
         return normalized
 
     @staticmethod
@@ -1413,6 +1467,20 @@ Use **Test** when the file exposes runtime dependencies.
             return False
         return abs(initial - 1.0) < 1e-9 and abs(multiplier - 2.0) < 1e-9 and abs(max_backoff - 8.0) < 1e-9
 
+    @staticmethod
+    def _coerce_bool(value: object, *, default: bool = False) -> bool:
+        if value is None:
+            return default
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, str):
+            normalized = value.strip().lower()
+            if normalized in {"1", "true", "yes", "on", "y"}:
+                return True
+            if normalized in {"0", "false", "no", "off", "n", ""}:
+                return False
+        return bool(value)
+
     def _normalize_plugins_payload(self, payload: dict) -> dict:
         normalized = deepcopy(payload)
         if "load_paths" not in normalized and isinstance(normalized.get("search_paths"), list):

package/src/deepscientist/daemon/api/handlers.py

@@ -14,7 +14,7 @@ from ... import __version__ as DEEPSCIENTIST_VERSION
 from ...gitops import commit_detail, compare_refs, diff_file_between_refs, diff_file_for_commit, export_git_graph, list_branch_canvas, log_ref_history
 from ...memory import MemoryService
 from ...quest import QuestService
-from ...shared import generate_id, read_text, resolve_within, sha256_text, utc_now
+from ...shared import generate_id, read_json, read_text, resolve_within, run_command, sha256_text, utc_now
 from ...runners import RunRequest
 
 
@@ -171,9 +171,9 @@ npm --prefix src/ui run build</pre>
 
     def cli_health(self) -> dict:
         online_channels = [
-            channel.status()
-            for channel in self.app.channels.values()
-            if channel.status().get("enabled") is not False
+            snapshot
+            for snapshot in self.app.list_connector_statuses()
+            if snapshot.get("enabled") is not False
         ]
         return {
             "status": "ok",
@@ -248,12 +248,15 @@ npm --prefix src/ui run build</pre>
             else []
         )
         force_connector_rebind_raw = body.get("force_connector_rebind")
-        force_connector_rebind = bool(force_connector_rebind_raw) and str(force_connector_rebind_raw).strip().lower() not in {
-            "0",
-            "false",
-            "no",
-            "off",
-        }
+        if force_connector_rebind_raw is None:
+            force_connector_rebind = True
+        else:
+            force_connector_rebind = bool(force_connector_rebind_raw) and str(force_connector_rebind_raw).strip().lower() not in {
+                "0",
+                "false",
+                "no",
+                "off",
+            }
         requested_baseline_ref = body.get("requested_baseline_ref")
         startup_contract = body.get("startup_contract")
         auto_start = body.get("auto_start") is True
@@ -645,8 +648,6 @@ npm --prefix src/ui run build</pre>
             session = self.app.bash_exec_service.get_session(quest_root, session_id)
         except FileNotFoundError:
             return 404, {"ok": False, "message": f"Unknown terminal session `{session_id}`."}
-        if str(session.get("kind") or "").lower() != "terminal":
-            return 400, {"ok": False, "message": "not_terminal_session"}
         if str(session.get("status") or "").lower() in {"completed", "failed", "terminated"}:
             return 409, {"ok": False, "message": "terminal_session_inactive", "session": session}
         try:
@@ -747,6 +748,12 @@ npm --prefix src/ui run build</pre>
     def git_branches(self, quest_id: str) -> dict:
         quest_root = self._fresh_quest_service()._quest_root(quest_id)
         payload = list_branch_canvas(quest_root, quest_id=quest_id)
+        research_state = self.app.quest_service.read_research_state(quest_root)
+        active_workspace_branch = str(research_state.get("current_workspace_branch") or "").strip() or None
+        research_head_branch = str(research_state.get("research_head_branch") or "").strip() or None
+        payload["active_workspace_ref"] = active_workspace_branch
+        payload["research_head_ref"] = research_head_branch
+        payload["workspace_mode"] = str(research_state.get("workspace_mode") or "quest").strip() or "quest"
         try:
             branch_summary = self.app.artifact_service.list_research_branches(quest_root)
         except Exception:
@@ -761,6 +768,8 @@ npm --prefix src/ui run build</pre>
             if not ref:
                 continue
             summary = branch_summary_by_name.get(ref)
+            node["active_workspace"] = ref == active_workspace_branch
+            node["research_head"] = ref == research_head_branch
             if not isinstance(summary, dict):
                 continue
             node["branch_no"] = summary.get("branch_no")
@@ -818,6 +827,126 @@ npm --prefix src/ui run build</pre>
         quest_root = self._fresh_quest_service()._quest_root(quest_id)
         return diff_file_between_refs(quest_root, base=base, head=head, path=file_path)
 
+    def file_change_diff(self, quest_id: str, path: str) -> dict:
+        query = self.parse_query(path)
+        run_id = ((query.get("run_id") or [""])[0] or "").strip()
+        event_id = ((query.get("event_id") or [""])[0] or "").strip() or None
+        raw_path = ((query.get("path") or [""])[0] or "").strip()
+        if not run_id or not raw_path:
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id or None,
+                event_id=event_id,
+                message="`run_id` and `path` are required.",
+                ok=False,
+            )
+
+        quest_root = self._fresh_quest_service()._quest_root(quest_id)
+        run_artifact = read_json(quest_root / ".ds" / "runs" / run_id / "artifact.json", default={})
+        if not isinstance(run_artifact, dict):
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                message="Historical patch unavailable. Run artifact metadata is missing.",
+                ok=False,
+            )
+
+        record = run_artifact.get("record") if isinstance(run_artifact.get("record"), dict) else {}
+        checkpoint = run_artifact.get("checkpoint") if isinstance(run_artifact.get("checkpoint"), dict) else {}
+        base = str(record.get("head_commit") or "").strip()
+        head = str(checkpoint.get("head") or "").strip()
+        branch = str(record.get("branch") or "").strip() or None
+        workspace_root = self._file_change_workspace_root(run_artifact, record)
+        relative_path = None
+        display_path = None
+
+        if not base or not head:
+            relative_path = self._relative_file_change_path(None, raw_path, workspace_root)
+            display_path = self._display_file_change_path(quest_root, raw_path, relative_path=relative_path)
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                base=base,
+                head=head,
+                branch=branch,
+                relative_path=relative_path,
+                display_path=display_path,
+                message="Historical patch unavailable. Run artifact metadata is missing the recorded commit range.",
+                ok=True,
+            )
+
+        repo_root = self._resolve_git_repo_root_for_file_change(raw_path, workspace_root)
+        relative_path = self._relative_file_change_path(repo_root, raw_path, workspace_root)
+        display_path = self._display_file_change_path(quest_root, raw_path, relative_path=relative_path)
+
+        if repo_root is None or not relative_path:
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                base=base,
+                head=head,
+                branch=branch,
+                relative_path=relative_path,
+                display_path=display_path,
+                message="Historical patch unavailable. DeepScientist could not map this file to a git worktree.",
+                ok=True,
+            )
+
+        try:
+            diff = diff_file_between_refs(repo_root, base=base, head=head, path=relative_path)
+        except Exception:
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                base=base,
+                head=head,
+                branch=branch,
+                relative_path=relative_path,
+                display_path=display_path,
+                message=(
+                    "Historical patch unavailable. The saved run checkpoint does not match the git repository "
+                    "that currently owns this file."
+                ),
+                ok=True,
+            )
+
+        if (
+            not diff.get("binary")
+            and not diff.get("lines")
+            and int(diff.get("added") or 0) == 0
+            and int(diff.get("removed") or 0) == 0
+        ):
+            return self._file_change_diff_unavailable(
+                raw_path=raw_path,
+                run_id=run_id,
+                event_id=event_id,
+                base=base,
+                head=head,
+                branch=branch,
+                relative_path=relative_path,
+                display_path=display_path,
+                message=(
+                    "Historical patch unavailable. This event only preserved file-level metadata or the edit "
+                    "did not land in the run's final checkpoint."
+                ),
+                ok=True,
+            )
+
+        return {
+            **diff,
+            "available": True,
+            "source": "run_range",
+            "display_path": display_path or relative_path,
+            "run_id": run_id,
+            "event_id": event_id,
+            "branch": branch,
+            "message": None,
+        }
+
     def git_commit_file(self, quest_id: str, path: str) -> dict:
         query = self.parse_query(path)
         sha = ((query.get("sha") or [""])[0] or "").strip()
@@ -1207,6 +1336,16 @@ npm --prefix src/ui run build</pre>
                 "ok": False,
                 "message": str(exc),
             }
+        raw_reasoning_effort = (
+            body.get("model_reasoning_effort")
+            if "model_reasoning_effort" in body
+            else runner_cfg.get("model_reasoning_effort")
+        )
+        reasoning_effort = (
+            str(raw_reasoning_effort).strip()
+            if raw_reasoning_effort is not None and str(raw_reasoning_effort).strip()
+            else ("xhigh" if raw_reasoning_effort is None else None)
+        )
         request = RunRequest(
             quest_id=quest_id,
             quest_root=quest_root,
@@ -1218,8 +1357,7 @@ npm --prefix src/ui run build</pre>
             approval_policy=runner_cfg.get("approval_policy", "on-request"),
             sandbox_mode=runner_cfg.get("sandbox_mode", "workspace-write"),
             turn_reason=body.get("turn_reason") or "user_message",
-            reasoning_effort=body.get("model_reasoning_effort")
-            or runner_cfg.get("model_reasoning_effort", "xhigh"),
+            reasoning_effort=reasoning_effort,
         )
         result = runner.run(request)
         if result.output_text:
@@ -1355,6 +1493,8 @@ npm --prefix src/ui run build</pre>
             result = self.app.config_manager.save_named_payload(name, body["structured"])
         else:
             result = self.app.config_manager.save_named_text(name, body.get("content", ""))
+        if result.get("ok") and name == "config":
+            result["runtime_reload"] = self.app.reload_runtime_config()
         if result.get("ok") and name == "connectors":
             result["runtime_reload"] = self.app.reload_connectors_config()
         if result.get("ok") and name == "runners":
@@ -1411,6 +1551,136 @@ npm --prefix src/ui run build</pre>
             return {}
         return json.loads(raw.decode("utf-8"))
 
+    @staticmethod
+    def _file_change_workspace_root(run_artifact: dict, record: dict) -> Path | None:
+        workspace_root = str(run_artifact.get("workspace_root") or record.get("workspace_root") or "").strip()
+        if not workspace_root:
+            return None
+        return Path(workspace_root).expanduser()
+
+    @staticmethod
+    def _file_change_path_candidates(raw_path: str, workspace_root: Path | None) -> list[Path]:
+        text = str(raw_path or "").strip()
+        if not text:
+            return []
+        raw_candidate = Path(text).expanduser()
+        candidates: list[Path] = []
+        if raw_candidate.is_absolute():
+            candidates.append(raw_candidate)
+        elif workspace_root is not None:
+            candidates.append(workspace_root / raw_candidate)
+        else:
+            candidates.append(raw_candidate)
+        if workspace_root is not None:
+            candidates.append(workspace_root)
+
+        resolved: list[Path] = []
+        seen: set[str] = set()
+        for candidate in candidates:
+            for variant in (candidate, candidate.resolve(strict=False)):
+                key = str(variant)
+                if key in seen:
+                    continue
+                seen.add(key)
+                resolved.append(variant)
+        return resolved
+
+    @staticmethod
+    def _git_probe_root(candidate: Path) -> Path:
+        if candidate.exists():
+            return candidate if candidate.is_dir() else candidate.parent
+        for parent in candidate.parents:
+            if parent.exists():
+                return parent
+        return candidate.parent
+
+    def _resolve_git_repo_root_for_file_change(self, raw_path: str, workspace_root: Path | None) -> Path | None:
+        for candidate in self._file_change_path_candidates(raw_path, workspace_root):
+            probe_root = self._git_probe_root(candidate)
+            if not str(probe_root).strip():
+                continue
+            result = run_command(["git", "rev-parse", "--show-toplevel"], cwd=probe_root, check=False)
+            if result.returncode != 0:
+                continue
+            top_level = result.stdout.strip()
+            if top_level:
+                return Path(top_level).resolve()
+        return None
+
+    def _relative_file_change_path(self, repo_root: Path | None, raw_path: str, workspace_root: Path | None) -> str | None:
+        if repo_root is None:
+            if Path(str(raw_path or "").strip()).is_absolute():
+                return None
+            normalized = str(raw_path or "").strip().replace("\\", "/").lstrip("/")
+            return normalized or None
+
+        repo_root_resolved = repo_root.resolve()
+        for candidate in self._file_change_path_candidates(raw_path, workspace_root):
+            try:
+                return candidate.relative_to(repo_root_resolved).as_posix()
+            except ValueError:
+                continue
+        if Path(str(raw_path or "").strip()).is_absolute():
+            return None
+        normalized = str(raw_path or "").strip().replace("\\", "/").lstrip("/")
+        return normalized or None
+
+    @staticmethod
+    def _display_file_change_path(quest_root: Path, raw_path: str, *, relative_path: str | None = None) -> str:
+        quest_root_resolved = quest_root.resolve()
+        for candidate in [Path(str(raw_path or "").strip()).expanduser()]:
+            for variant in (candidate, candidate.resolve(strict=False)):
+                try:
+                    relative = variant.relative_to(quest_root_resolved)
+                except ValueError:
+                    continue
+                parts = relative.parts
+                if len(parts) >= 3 and parts[0] == ".ds" and parts[1] == "worktrees":
+                    branch_root = parts[2]
+                    remainder = Path(*parts[3:]).as_posix() if len(parts) > 3 else ""
+                    return f"{branch_root}/{remainder}" if remainder else branch_root
+                return relative.as_posix()
+        if relative_path:
+            return relative_path
+        text = str(raw_path or "").strip()
+        return Path(text).name or text
+
+    @staticmethod
+    def _file_change_diff_unavailable(
+        *,
+        raw_path: str,
+        run_id: str | None,
+        event_id: str | None,
+        message: str,
+        ok: bool,
+        base: str = "",
+        head: str = "",
+        branch: str | None = None,
+        relative_path: str | None = None,
+        display_path: str | None = None,
+    ) -> dict:
+        normalized_path = relative_path or str(raw_path or "").strip()
+        return {
+            "ok": ok,
+            "available": False,
+            "source": "unavailable",
+            "run_id": run_id,
+            "event_id": event_id,
+            "branch": branch,
+            "display_path": display_path or normalized_path,
+            "base": base,
+            "head": head,
+            "path": normalized_path,
+            "old_path": None,
+            "status": "modified",
+            "binary": False,
+            "added": 0,
+            "removed": 0,
+            "lines": [],
+            "truncated": False,
+            "message": message,
+        }
+
     @staticmethod
     def _markdown_title(path: Path) -> str:
         content = read_text(path)

package/src/deepscientist/daemon/api/router.py

@@ -60,6 +60,7 @@ ROUTES: list[tuple[str, re.Pattern[str], str]] = [
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/commit$"), "git_commit"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/diff-file$"), "git_diff_file"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/git/commit-file$"), "git_commit_file"),
+    ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/operations/file-change-diff$"), "file_change_diff"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/runs$"), "runs"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/memory$"), "quest_memory"),
     ("GET", re.compile(r"^/api/quests/(?P<quest_id>[^/]+)/documents$"), "documents"),