@aa2246740/dsh-resume 0.2.5 → 0.2.7

package/resources/dsh_session_reader.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Extend Grok's foreign-session reader with inert Grok, Pi, and ZCode adapters."""
+"""Extend Grok's foreign-session reader with inert Grok, Pi, ZCode, Qoder, and WorkBuddy adapters."""
 
 from __future__ import annotations
 
@@ -25,7 +25,7 @@ for _stream in (sys.stdout, sys.stderr):
         pass
 
 
-EXTENDED_TOOLS = ("grok", "pi", "zcode")
+EXTENDED_TOOLS = ("grok", "pi", "qoder", "workbuddy", "zcode")
 TOOLS = (*core.TOOLS, *EXTENDED_TOOLS)
 
 
@@ -46,6 +46,140 @@ def _same_cwd(left: Any, right: str) -> bool:
     )
 
 
+# Output boundary for rendered transcripts. Foreign tool arguments and results
+# are copied verbatim by the provider parsers; this pass runs after that copy.
+# An Authorization value includes its scheme. Replacing only the word Bearer or
+# Basic leaves the opaque credential behind, and a quoted JSON key is not a bare
+# assignment. Dict keys are removed before nested values are copied out.
+_MAX_JSON_REDACTION_DEPTH = 8
+_SENSITIVE_LAST_PIECES = {"apikey", "authorization", "password", "secret", "token"}
+_SENSITIVE_ANY_PIECES = {"authorization", "password", "secret"}
+_COMPACT_KEY_SUFFIXES = (
+    "accesstoken",
+    "apikey",
+    "clientsecret",
+    "idtoken",
+    "refreshtoken",
+)
+
+
+def _key_pieces(key: str) -> list[str]:
+    broken = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", key)
+    broken = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", broken)
+    return [piece.lower() for piece in re.findall(r"[A-Za-z0-9]+", broken)]
+
+
+def _is_sensitive_key(key: str) -> bool:
+    pieces = _key_pieces(key)
+    if not pieces:
+        return False
+    if pieces[-1] in _SENSITIVE_LAST_PIECES or pieces[-1].endswith("apikey"):
+        return True
+    if len(pieces) >= 2 and pieces[-2:] == ["api", "key"]:
+        return True
+    if any(piece in _SENSITIVE_ANY_PIECES for piece in pieces):
+        return True
+    compact = "".join(pieces)
+    return any(
+        compact == suffix or compact.endswith(suffix) for suffix in _COMPACT_KEY_SUFFIXES
+    )
+
+
+_QUOTE = r"""(?:\\?["'])"""
+_KEY_BODY = (
+    r"[A-Za-z0-9_.-]*?"
+    r"(?:access[_-]?token|refresh[_-]?token|id[_-]?token|client[_-]?secret|"
+    r"api[_-]?key|authorization|password|secret|token)"
+)
+# Bearer/Basic must be consumed with the following token. A bare \S+ stops at
+# the scheme word and the credential survives the later scheme pass.
+_SECRET_VALUE = (
+    r"(?:(?:Bearer|Basic)\s+\S+"
+    r"|\\?\"(?:Bearer|Basic)\s+(?:\\.|[^\"\\])*\\?\""
+    r"|\\?'(?:Bearer|Basic)\s+(?:\\.|[^'\\])*\\?'"
+    r"|\\?\"(?:\\.|[^\"\\])*\\?\""
+    r"|\\?'(?:\\.|[^'\\])*\\?'"
+    r"|\S+)"
+)
+_ASSIGNMENT_SECRET_RE = re.compile(
+    rf"(?i)((?<![A-Za-z0-9_]){_QUOTE}?({_KEY_BODY})(?![A-Za-z0-9_]){_QUOTE}?\s*[=:]\s*){_SECRET_VALUE}"
+)
+_SCHEME_SECRET_RE = re.compile(r"(?i)\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}")
+_SK_SECRET_RE = re.compile(r"\bsk-[A-Za-z0-9_-]{8,}")
+
+
+def _assignment_redaction(match: re.Match[str]) -> str:
+    if not _is_sensitive_key(match.group(2)):
+        return match.group(0)
+    return match.group(1) + "[REDACTED]"
+
+
+def _apply_secret_patterns(value: str) -> str:
+    value = _ASSIGNMENT_SECRET_RE.sub(_assignment_redaction, value)
+    value = _SCHEME_SECRET_RE.sub(r"\1 [REDACTED]", value)
+    return _SK_SECRET_RE.sub("[REDACTED]", value)
+
+
+def _parse_json_container(value: str) -> Any | None:
+    stripped = value.strip()
+    if len(stripped) < 2 or stripped[0] not in "{[":
+        return None
+    try:
+        parsed = json.loads(stripped)
+    except json.JSONDecodeError:
+        return None
+    if isinstance(parsed, (dict, list)):
+        return parsed
+    return None
+
+
+def _redact_string(value: str, depth: int) -> str:
+    if depth < _MAX_JSON_REDACTION_DEPTH:
+        parsed = _parse_json_container(value)
+        if parsed is not None:
+            redacted = _redact_output(parsed, depth + 1)
+            if redacted != parsed:
+                try:
+                    return json.dumps(redacted, ensure_ascii=False)
+                except (TypeError, ValueError):
+                    pass
+    return _apply_secret_patterns(value)
+
+
+def _redact_text(value: str) -> str:
+    return _redact_string(value, 0)
+
+
+def _redact_output(value: Any, depth: int = 0) -> Any:
+    if isinstance(value, str):
+        return _redact_string(value, depth)
+    if isinstance(value, list):
+        return [_redact_output(item, depth) for item in value]
+    if isinstance(value, dict):
+        redacted: dict[Any, Any] = {}
+        for key, item in value.items():
+            if isinstance(key, str) and _is_sensitive_key(key):
+                redacted[key] = "[REDACTED]"
+            else:
+                redacted[key] = _redact_output(item, depth)
+        return redacted
+    return value
+
+
+def _split_typed_records(
+    records: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], int]:
+    """Drop records whose type cannot be used in set membership checks."""
+    kept: list[dict[str, Any]] = []
+    corrupt = 0
+    for record in records:
+        if isinstance(record.get("type"), str):
+            kept.append(record)
+        else:
+            corrupt += 1
+    return kept, corrupt
+
+
 def _read_json(path: Path) -> dict[str, Any]:
     try:
         value = json.loads(path.read_text(encoding="utf-8", errors="replace"))
@@ -1739,9 +1873,1047 @@ class ZCodeAdapter(ProviderAdapter):
         return self._read_sqlite(candidate, max_tool_chars)
 
 
+_QODER_INFORMATIONAL_TYPES = {
+    "runtime-config",
+    "file-history-snapshot",
+    "last-prompt",
+    # Housekeeping records emitted by qodercli: injected context listings,
+    # leaf tracking, workspace metadata, and worktree state. Known and
+    # intentionally not rendered — attachment content is Qoder-injected
+    # context, not user/assistant turns.
+    "attachment",
+    "active-leaf",
+    "workspace-directories",
+    "worktree-state",
+}
+_QODER_KNOWN_TYPES = set(core.CLAUDE_KNOWN_TYPES) | _QODER_INFORMATIONAL_TYPES
+
+_QODER_MESSAGE_TYPES = {"user", "assistant", "system"}
+
+
+def _qoder_message_eligible(record: dict[str, Any]) -> bool:
+    record_type = record.get("type")
+    return (
+        isinstance(record_type, str)
+        and record_type in _QODER_MESSAGE_TYPES
+        and not record.get("isSidechain")
+        and isinstance(record.get("uuid"), str)
+        and bool(record.get("uuid"))
+    )
+
+
+def _repair_qoder_parents(records: list[dict[str, Any]]) -> None:
+    """Repoint message parent links that cross non-message records.
+
+    qodercli interleaves housekeeping records (``attachment``, ``active-leaf``,
+    ...) inside the parentUuid chain, so an assistant's parentUuid can point at
+    a record that is filtered out before rendering. Walk each message record's
+    chain through those non-message records to the nearest message ancestor so
+    no turns (notably the opening user prompt) are orphaned.
+    """
+    by_uuid = {
+        record["uuid"]: record
+        for record in records
+        if isinstance(record.get("uuid"), str) and record["uuid"]
+    }
+    for record in records:
+        if not _qoder_message_eligible(record):
+            continue
+        parent = core._claude_parent(record)
+        if parent is None or parent not in by_uuid:
+            continue
+        seen: set[str] = {str(record.get("uuid"))}
+        resolved = parent
+        while resolved is not None and resolved in by_uuid:
+            target = by_uuid[resolved]
+            if _qoder_message_eligible(target):
+                break
+            if resolved in seen:
+                resolved = None
+                break
+            seen.add(resolved)
+            resolved = core._claude_parent(target)
+        if resolved != parent:
+            core._set_claude_parent(record, resolved)
+
+
+def _qoder_workspace_dir(records: list[dict[str, Any]]) -> str | None:
+    for record in records:
+        if record.get("type") != "workspace-directories":
+            continue
+        directories = record.get("directories")
+        if isinstance(directories, list):
+            value = next(
+                (
+                    item
+                    for item in directories
+                    if isinstance(item, str) and item.strip()
+                ),
+                None,
+            )
+            if value:
+                return value
+    return None
+
+
+def _qoder_ide_roots() -> list[Path]:
+    """Qoder IDE SharedClientCache transcript roots (flat layout, same JSONL schema)."""
+    configured = os.environ.get("QODER_IDE_CACHE_DIR")
+    if configured:
+        return [Path(configured).expanduser()]
+    home = Path.home()
+    candidates = [
+        home / "Library/Application Support/Qoder/SharedClientCache/cli/projects",
+        home / ".config/Qoder/SharedClientCache/cli/projects",
+    ]
+    appdata = os.environ.get("APPDATA")
+    if appdata:
+        candidates.append(Path(appdata) / "Qoder/SharedClientCache/cli/projects")
+    output: list[Path] = []
+    for path in candidates:
+        if path not in output:
+            output.append(path)
+    return output
+
+
+class QoderAdapter(ProviderAdapter):
+    """Read Qoder's Claude-Code-shaped JSONL transcripts as inert history.
+
+    Primary store: ``$QODER_CONFIG_DIR/projects/<slug>/<session-id>.jsonl``
+    (default ``~/.qoder``; ``QODER_HOME`` is accepted as a fallback alias).
+    Qoder IDE ``SharedClientCache/cli/projects`` transcripts are a second,
+    flat-layout root (overridable with ``QODER_IDE_CACHE_DIR``). Every record
+    carries ``cwd``/``gitBranch``; ``isSidechain`` subagent records and
+    informational ``runtime-config``/``file-history-snapshot``/``last-prompt``
+    records are skipped. The encrypted ``<session-id>/state.json`` siblings,
+    ``logs/sessions`` run logs, ``.auth`` credentials, and ``settings.json``
+    are never read.
+    """
+
+    tool = "qoder"
+
+    @staticmethod
+    def _home() -> Path:
+        configured = os.environ.get("QODER_CONFIG_DIR") or os.environ.get("QODER_HOME")
+        return Path(configured).expanduser() if configured else Path.home() / ".qoder"
+
+    @classmethod
+    def _projects_root(cls) -> Path:
+        return cls._home() / "projects"
+
+    def _iter_transcripts(self) -> Iterable[tuple[Path, str]]:
+        root = self._projects_root()
+        if root.is_dir() and not root.is_symlink():
+            try:
+                buckets = sorted(root.iterdir(), key=lambda item: item.name)
+            except OSError:
+                buckets = []
+            for bucket in buckets:
+                if not bucket.is_dir() or bucket.is_symlink():
+                    continue
+                try:
+                    children = sorted(bucket.iterdir(), key=lambda item: item.name)
+                except OSError:
+                    continue
+                for child in children:
+                    if child.is_file() and not child.is_symlink() and child.suffix == ".jsonl":
+                        yield child, "qoder-cli"
+        for ide_root in _qoder_ide_roots():
+            if not ide_root.is_dir() or ide_root.is_symlink():
+                continue
+            try:
+                children = sorted(ide_root.iterdir(), key=lambda item: item.name)
+            except OSError:
+                continue
+            for child in children:
+                if child.is_file() and not child.is_symlink() and child.suffix == ".jsonl":
+                    yield child, "qoder-ide-cache"
+
+    def _file_candidate(
+        self,
+        path: Path,
+        source: str,
+        cwd: str,
+        *,
+        require_cwd: bool,
+        slug_matches: bool = False,
+    ) -> dict[str, Any] | None:
+        try:
+            records, _malformed = core._read_plain_jsonl(path)
+        except core.ReaderError as exc:
+            core._add_warning(
+                self.warnings,
+                "transcript_unreadable",
+                f"Skipped unreadable Qoder transcript {path}: {exc}",
+            )
+            return None
+        session_id: str | None = None
+        actual_cwd: str | None = None
+        branch: str | None = None
+        has_turns = False
+        timestamps: list[int] = []
+        for record in records:
+            if session_id is None:
+                value = record.get("sessionId")
+                if isinstance(value, str) and value.strip():
+                    session_id = value
+            if actual_cwd is None:
+                value = record.get("cwd")
+                if isinstance(value, str) and value.strip():
+                    actual_cwd = value
+            value = record.get("gitBranch")
+            if isinstance(value, str) and value.strip():
+                branch = value
+            record_type = record.get("type")
+            if (
+                isinstance(record_type, str)
+                and record_type in {"user", "assistant"}
+                and isinstance(record.get("message"), dict)
+            ):
+                has_turns = True
+            stamp = core._timestamp_to_millis(record.get("timestamp"))
+            if stamp is not None:
+                timestamps.append(stamp)
+        if actual_cwd is None:
+            actual_cwd = _qoder_workspace_dir(records)
+        if not has_turns:
+            return None
+        # A directory slug is only a fallback for transcripts that never
+        # recorded a cwd. project-a and project_a share a slug, so an explicit
+        # cwd must match the requested workspace on its own.
+        recorded_cwd = actual_cwd.strip() if isinstance(actual_cwd, str) else ""
+        if require_cwd:
+            if not recorded_cwd:
+                if not slug_matches:
+                    return None
+                actual_cwd = cwd
+            elif not _same_cwd(recorded_cwd, cwd):
+                return None
+        if session_id is None:
+            session_id = path.stem
+        title = core._claude_title(records, [])
+        if title is None:
+            title = next(
+                (
+                    core._one_line(text, 200)
+                    for record in records
+                    if record.get("type") == "user" and not record.get("isSidechain")
+                    for text in [
+                        core._content_text(
+                            (record.get("message") or {}).get("content")
+                            if isinstance(record.get("message"), dict)
+                            else None
+                        )
+                    ]
+                    if text.strip()
+                ),
+                None,
+            )
+        updated_ms = timestamps[-1] if timestamps else core._mtime_millis(path)
+        return {
+            "tool": "qoder",
+            "source": source,
+            "store": "projects" if source == "qoder-cli" else "ide-cache",
+            "session_id": core._safe_text(session_id),
+            "path": str(path),
+            "title": core._safe_text(title) if title else None,
+            "cwd": core._safe_text(actual_cwd) if actual_cwd else None,
+            "branch": core._safe_text(branch) if branch else None,
+            "created_at": core._iso_from_millis(timestamps[0] if timestamps else None),
+            "updated_at_ms": updated_ms,
+            "updated_at": core._iso_from_millis(updated_ms),
+            "source_repo_root_path": None,
+        }
+
+    def discover(self, cwd: str, within_min: int) -> list[dict[str, Any]]:
+        self.warnings = []
+        expected_slug = core.slugify(cwd)
+        sessions: list[dict[str, Any]] = []
+        for path, source in self._iter_transcripts():
+            slug_matches = source == "qoder-cli" and path.parent.name == expected_slug
+            candidate = self._file_candidate(
+                path, source, cwd, require_cwd=True, slug_matches=slug_matches
+            )
+            if candidate is None:
+                continue
+            if core._within(int(candidate.get("updated_at_ms") or 0), within_min):
+                sessions.append(candidate)
+        return core._sort_and_dedupe(sessions)
+
+    def candidate_from_path(self, raw_path: str, cwd: str) -> dict[str, Any] | None:
+        path = Path(raw_path).expanduser()
+        if not path.is_file() or path.is_symlink() or path.suffix != ".jsonl":
+            return None
+        ide = any(path.parent == root for root in _qoder_ide_roots())
+        candidate = self._file_candidate(
+            path, "qoder-ide-cache" if ide else "qoder-cli", cwd, require_cwd=False
+        )
+        if candidate is not None:
+            candidate["requested_cwd"] = cwd
+        return candidate
+
+    def find_id(self, session_id: str, cwd: str) -> dict[str, Any] | None:
+        wanted = session_id.casefold()
+        matches: list[dict[str, Any]] = []
+        deferred: list[tuple[Path, str]] = []
+        for path, source in self._iter_transcripts():
+            if path.stem.casefold() == wanted:
+                candidate = self._file_candidate(path, source, cwd, require_cwd=False)
+                if candidate is not None:
+                    candidate["requested_cwd"] = cwd
+                    matches.append(candidate)
+            else:
+                deferred.append((path, source))
+        if not matches:
+            for path, source in deferred:
+                candidate = self._file_candidate(path, source, cwd, require_cwd=False)
+                if candidate is None:
+                    continue
+                if str(candidate.get("session_id", "")).casefold() == wanted:
+                    candidate["requested_cwd"] = cwd
+                    matches.append(candidate)
+        if len(matches) == 1:
+            return matches[0]
+        if len(matches) > 1:
+            raise core.AmbiguousReference(session_id, matches)
+        return None
+
+    def read(self, candidate: dict[str, Any], max_tool_chars: int) -> dict[str, Any]:
+        path = Path(str(candidate["path"])).expanduser()
+        records, malformed = core._read_plain_jsonl(path)
+        warnings: list[dict[str, str]] = []
+        records, corrupt = _split_typed_records(records)
+        if corrupt:
+            core._add_warning(
+                warnings,
+                "corrupt_records_skipped",
+                f"Skipped {corrupt} Qoder record(s) whose type was not a string.",
+            )
+        if malformed:
+            core._add_warning(
+                warnings,
+                "malformed_records_skipped",
+                f"Skipped {malformed} malformed Qoder transcript record(s).",
+            )
+        unknown = sum(
+            1
+            for record in records
+            if isinstance(record.get("type"), str) and record.get("type") not in _QODER_KNOWN_TYPES
+        )
+        if unknown:
+            core._add_warning(
+                warnings,
+                "unknown_records_skipped",
+                f"Skipped {unknown} unknown Qoder record(s) without interpreting their payloads.",
+            )
+        sidechain = sum(1 for record in records if record.get("isSidechain"))
+        if sidechain:
+            core._add_warning(
+                warnings,
+                "sidechain_records_skipped",
+                f"Skipped {sidechain} Qoder subagent (isSidechain) record(s).",
+            )
+        _repair_qoder_parents(records)
+        messages = core._prepare_claude_messages(records, warnings)
+        leaf = core._claude_leaf(messages, warnings)
+        chain: list[dict[str, Any]] = []
+        if leaf is not None:
+            chain, _seen = core._claude_chain(messages, leaf, warnings)
+        replacements = core._claude_replacement_ids(records)
+        turns = [
+            turn
+            for record in chain
+            for turn in [core._render_claude_record(record, max_tool_chars, replacements)]
+            if turn is not None
+        ]
+        metadata_records = chain if chain else records
+        cwd = next(
+            (
+                record.get("cwd")
+                for record in metadata_records
+                if isinstance(record.get("cwd"), str) and record["cwd"].strip()
+            ),
+            None,
+        ) or _qoder_workspace_dir(records) or (
+            candidate.get("cwd") if isinstance(candidate.get("cwd"), str) else None
+        )
+        requested = candidate.get("requested_cwd")
+        if (
+            isinstance(requested, str)
+            and requested
+            and isinstance(cwd, str)
+            and not _same_cwd(cwd, requested)
+        ):
+            core._add_warning(
+                warnings,
+                "foreign_cwd_mismatch",
+                f"Qoder session cwd {cwd} differs from the current workspace {requested}.",
+            )
+        branch = next(
+            (
+                record.get("gitBranch")
+                for record in reversed(metadata_records)
+                if isinstance(record.get("gitBranch"), str) and record["gitBranch"].strip()
+            ),
+            None,
+        ) or (candidate.get("branch") if isinstance(candidate.get("branch"), str) else None)
+        model = next(
+            (
+                value
+                for record in reversed(records)
+                if record.get("type") == "assistant"
+                for value in [
+                    (record.get("message") or {}).get("model")
+                    if isinstance(record.get("message"), dict)
+                    else None
+                ]
+                if isinstance(value, str) and value.strip()
+            ),
+            None,
+        )
+        timestamps = [
+            stamp
+            for record in chain
+            for stamp in [core._timestamp_to_millis(record.get("timestamp"))]
+            if stamp is not None
+        ]
+        title = candidate.get("title") or core._claude_title(records, turns)
+        session_id = candidate.get("session_id") or path.stem
+        result = {
+            "tool": "qoder",
+            "source": str(candidate.get("source") or "qoder-cli"),
+            "session_id": core._safe_text(session_id),
+            "path": str(path),
+            "title": title,
+            "cwd": cwd,
+            "branch": branch,
+            "created_at": (
+                core._iso_from_millis(timestamps[0])
+                if timestamps
+                else candidate.get("created_at")
+            ),
+            "updated_at": (
+                core._iso_from_millis(timestamps[-1])
+                if timestamps
+                else candidate.get("updated_at") or core._iso_from_millis(core._mtime_millis(path))
+            ),
+            "source_repo_root_path": None,
+            "model": core._safe_text(model) if model else None,
+            "turns": turns,
+            "warnings": warnings,
+        }
+        return _redact_output(core._finalize_result(result))
+
+
+_WORKBUDDY_CUSTOM_ITEM_TYPES = {
+    "custom-title",
+    "ai-title",
+    "file-history-snapshot",
+    "summary",
+    "topic",
+    "goal-result",
+    "goal-progress",
+    "resend-fork-notice",
+}
+
+_WORKBUDDY_USER_QUERY_RE = re.compile(r"<user_query>([\s\S]*?)</user_query>")
+_WORKBUDDY_SYSTEM_TAG_RES = [
+    re.compile(rf"<{tag}\b[^>]*>[\s\S]*?</{tag}>\s*")
+    for tag in (
+        "system-reminder",
+        "additional_data",
+        "user_info",
+        "cb_summary",
+        "rules",
+        "content_policy",
+        "agent_skills",
+        "always_applied_workspace_rules",
+        "agent_requestable_workspace_rules",
+        "project_context",
+        "communication",
+        "tool_calling",
+        "making_code_changes",
+        "response_language",
+        "git_status",
+    )
+]
+_WORKBUDDY_TEAMMATE_RE = re.compile(
+    r"^\s*<teammate-message\b[^>]*>[\s\S]*</teammate-message>\s*$",
+    re.IGNORECASE,
+)
+
+
+def _workbuddy_int32(value: int) -> int:
+    value &= 0xFFFFFFFF
+    return value - 0x100000000 if value >= 0x80000000 else value
+
+
+def _workbuddy_djb2_base36(value: str) -> str:
+    """WorkBuddy's djb2 over UTF-8 bytes rendered as base36."""
+    state = 5381
+    for byte in value.encode("utf-8"):
+        state = _workbuddy_int32(state * 33) ^ byte
+    state &= 0xFFFFFFFF
+    digits = "0123456789abcdefghijklmnopqrstuvwxyz"
+    if state == 0:
+        return "0"
+    output = ""
+    while state:
+        state, remainder = divmod(state, 36)
+        output = digits[remainder] + output
+    return output
+
+
+def _workbuddy_truncate_utf8(value: str, max_bytes: int) -> str:
+    encoded = value.encode("utf-8")
+    if len(encoded) <= max_bytes:
+        return value
+    return encoded[:max_bytes].decode("utf-8", errors="ignore")
+
+
+def _workbuddy_project_slug(value: str) -> str:
+    """compressWorkspacePathName: / \\ : -> -, trim, collapse, hash long paths."""
+    base = re.sub(r"[/\\:]", "-", value)
+    base = re.sub(r"-+", "-", base.strip("-"))
+    if len(base.encode("utf-8")) <= 255:
+        return base
+    return f"{_workbuddy_truncate_utf8(base, 180)}-{_workbuddy_djb2_base36(base)}"
+
+
+def _workbuddy_teammate(item: dict[str, Any]) -> bool:
+    provider = item.get("providerData")
+    if isinstance(provider, dict):
+        teammate = provider.get("teammateMessage")
+        if isinstance(teammate, dict) and isinstance(teammate.get("from"), str):
+            return True
+    text = _workbuddy_content_text(item.get("content"))
+    return bool(text and _WORKBUDDY_TEAMMATE_RE.match(text))
+
+
+def _workbuddy_meta_record(item: dict[str, Any]) -> bool:
+    """Records the WorkBuddy app never shows as real user/assistant turns."""
+    provider = item.get("providerData")
+    provider = provider if isinstance(provider, dict) else {}
+    if (
+        provider.get("isMeta") is True
+        or provider.get("isCompactInternal") is True
+        or isinstance(provider.get("compactType"), str)
+        or _workbuddy_teammate(item)
+    ):
+        return True
+    if item.get("role") == "user":
+        if provider.get("skipRun") is True:
+            return True
+        client_meta = provider.get("clientMeta")
+        codebuddy = (
+            client_meta.get("codebuddy.ai")
+            if isinstance(client_meta, dict) and isinstance(client_meta.get("codebuddy.ai"), dict)
+            else {}
+        )
+        if codebuddy.get("queueOrigin") == "steer":
+            return True
+    return False
+
+
+def _workbuddy_content_text(content: Any) -> str:
+    parts: list[str] = []
+    for block in core._blocks(content):
+        text = block.get("text")
+        if isinstance(text, str):
+            parts.append(text)
+    return "\n".join(parts)
+
+
+def _workbuddy_strip_system_tags(text: str) -> str:
+    stripped = text
+    for pattern in _WORKBUDDY_SYSTEM_TAG_RES:
+        stripped = pattern.sub("", stripped)
+    stripped = _WORKBUDDY_USER_QUERY_RE.sub(lambda match: match.group(1), stripped)
+    return stripped.strip()
+
+
+def _workbuddy_user_text(content: Any) -> str:
+    """Visible user text: providerData.content first, else tag-stripped input_text."""
+    if isinstance(content, str):
+        return _workbuddy_strip_system_tags(content)
+    if not isinstance(content, list):
+        return ""
+    for block in content:
+        if isinstance(block, str):
+            extracted = _workbuddy_strip_system_tags(block)
+            if extracted:
+                return extracted
+            continue
+        if not isinstance(block, dict):
+            continue
+        block_type = block.get("type")
+        if block_type and block_type != "input_text":
+            continue
+        text = block.get("text") or block.get("input_text")
+        if not isinstance(text, str) or not text.strip():
+            continue
+        if "<image_local_path>" in text:
+            continue
+        if text.lstrip().startswith("<system-reminder") and "<user_query>" not in text:
+            continue
+        provider = block.get("providerData")
+        if isinstance(provider, dict) and isinstance(provider.get("content"), str):
+            provider_content = provider["content"].strip()
+            if provider_content:
+                return core._safe_text(provider_content)
+        extracted = _workbuddy_strip_system_tags(text)
+        if extracted:
+            return extracted
+    return ""
+
+
+def _workbuddy_append_turn(
+    turns: list[dict[str, Any]],
+    role: str,
+    text: str,
+) -> None:
+    if not text:
+        return
+    if (
+        turns
+        and turns[-1].get("role") == role
+        and not turns[-1].get("tool_calls")
+        and not turns[-1].get("tool_results")
+    ):
+        turns[-1]["text"] = core._safe_text(turns[-1].get("text")) + "\n" + text
+        return
+    turns.append(core._turn(role, text=text))
+
+
+def _workbuddy_call_id(record: dict[str, Any], index: int) -> str:
+    for key in ("callId", "call_id", "id"):
+        value = record.get(key)
+        if isinstance(value, str) and value:
+            return value
+    return f"workbuddy-call-{index}"
+
+
+def _workbuddy_result_content(record: dict[str, Any], max_tool_chars: int) -> str:
+    output = record.get("output")
+    if isinstance(output, str) and output.strip():
+        return core._json_preview(output, max_tool_chars)
+    provider = record.get("providerData")
+    if isinstance(provider, dict):
+        tool_result = provider.get("toolResult") or provider.get("workbuddyToolResult")
+        if tool_result is not None:
+            return core._json_preview(tool_result, max_tool_chars)
+    return core._json_preview(output, max_tool_chars)
+
+
+def _workbuddy_result_is_error(record: dict[str, Any]) -> bool:
+    status = record.get("status")
+    if isinstance(status, str) and status in {"incomplete", "failed", "error"}:
+        return True
+    provider = record.get("providerData")
+    if isinstance(provider, dict):
+        tool_result = provider.get("toolResult")
+        if isinstance(tool_result, dict) and tool_result.get("isError") is True:
+            return True
+    return False
+
+
+def _workbuddy_session_info(records: list[dict[str, Any]]) -> dict[str, Any]:
+    """cwd, titles, model, and timestamps exactly like the app's JSONL scan."""
+    cwd: str | None = None
+    custom_title: str | None = None
+    ai_title: str | None = None
+    topic: str | None = None
+    first_user_text: str | None = None
+    model: str | None = None
+    first_ts: int | None = None
+    last_ts: int | None = None
+    has_turn = False
+    for record in records:
+        timestamp = core._timestamp_to_millis(record.get("timestamp"))
+        if timestamp is not None:
+            if first_ts is None:
+                first_ts = timestamp
+            last_ts = timestamp
+        if cwd is None:
+            value = record.get("cwd")
+            if isinstance(value, str) and value:
+                cwd = value
+        if model is None:
+            value = record.get("model")
+            if isinstance(value, str) and value:
+                model = value
+        record_type = record.get("type")
+        if record_type == "custom-title":
+            value = record.get("customTitle")
+            if isinstance(value, str) and value.strip():
+                custom_title = value.strip()
+        elif record_type == "ai-title":
+            value = record.get("aiTitle")
+            if ai_title is None and isinstance(value, str) and value.strip():
+                ai_title = value.strip()
+        elif record_type == "topic":
+            value = record.get("topic")
+            if topic is None and isinstance(value, str) and value.strip():
+                topic = value.strip()
+        elif record_type == "message" and record.get("role") in {"user", "assistant"}:
+            if _workbuddy_meta_record(record):
+                continue
+            has_turn = True
+            if first_user_text is None and record.get("role") == "user":
+                text = _workbuddy_user_text(record.get("content"))
+                if text:
+                    first_user_text = core._one_line(text, 120)
+    title = custom_title or ai_title or topic
+    if not title and first_user_text:
+        title = (
+            first_user_text if len(first_user_text) <= 50
+            else first_user_text[:50] + "..."
+        )
+    return {
+        "cwd": cwd,
+        "title": title,
+        "model": model,
+        "first_ts": first_ts,
+        "last_ts": last_ts,
+        "has_turn": has_turn,
+    }
+
+
+class WorkBuddyAdapter(ProviderAdapter):
+    """Read WorkBuddy/CodeBuddy projects JSONL as inert history.
+
+    Session transcripts live at ``<config>/projects/<compressedCwd>/<id>.jsonl``
+    where ``<config>`` resolves like the app: ``WORKBUDDY_CONFIG_DIR`` or
+    ``CODEBUDDY_CONFIG_DIR``, else ``~/.workbuddy-ai`` (this product's
+    ``dataFolderName``) or the legacy ``~/.workbuddy``. ``WORKBUDDY_DATA_FOLDER_NAME``
+    names a different folder under home. ``<id>.quickask`` marked files are
+    quick-ask scratch sessions and are skipped. ``workbuddy.db`` is only an
+    index; the JSONL transcript is authoritative.
+    """
+
+    tool = "workbuddy"
+
+    @staticmethod
+    def _roots() -> list[Path]:
+        for variable in ("WORKBUDDY_CONFIG_DIR", "CODEBUDDY_CONFIG_DIR"):
+            value = os.environ.get(variable, "").strip()
+            if value:
+                return [Path(value).expanduser()]
+        folder = os.environ.get("WORKBUDDY_DATA_FOLDER_NAME", "").strip()
+        if folder:
+            return [Path.home() / folder]
+        return [Path.home() / ".workbuddy-ai", Path.home() / ".workbuddy"]
+
+    @staticmethod
+    def _project_names(cwd: str) -> list[str]:
+        raw = str(Path(cwd).expanduser())
+        absolute = _absolute_cwd(cwd)
+        canonical = _canonical_cwd(cwd)
+        return list(
+            dict.fromkeys(
+                _workbuddy_project_slug(value)
+                for value in (raw, absolute, canonical)
+            )
+        )
+
+    @classmethod
+    def _iter_jsonl(cls, projects: Path, names: Iterable[str]) -> Iterator[Path]:
+        seen: set[Path] = set()
+        for name in names:
+            workspace = projects / name
+            if not workspace.is_dir() or workspace.is_symlink():
+                continue
+            for path in sorted(workspace.glob("*.jsonl"), key=lambda item: item.name):
+                if path.is_file() and not path.is_symlink() and path not in seen:
+                    seen.add(path)
+                    yield path
+        if seen or not projects.is_dir() or projects.is_symlink():
+            return
+        # Slug collisions are lossy; fall back to record-level cwd matching.
+        for workspace in sorted(projects.iterdir(), key=lambda item: item.name):
+            if not workspace.is_dir() or workspace.is_symlink():
+                continue
+            for path in sorted(workspace.glob("*.jsonl"), key=lambda item: item.name):
+                if path.is_file() and not path.is_symlink() and path not in seen:
+                    seen.add(path)
+                    yield path
+
+    @classmethod
+    def _files_for_cwd(cls, cwd: str) -> Iterator[Path]:
+        names = cls._project_names(cwd)
+        for root in cls._roots():
+            yield from cls._iter_jsonl(root / "projects", names)
+
+    @classmethod
+    def _all_files(cls) -> Iterator[Path]:
+        for root in cls._roots():
+            projects = root / "projects"
+            if not projects.is_dir() or projects.is_symlink():
+                continue
+            for workspace in sorted(projects.iterdir(), key=lambda item: item.name):
+                if not workspace.is_dir() or workspace.is_symlink():
+                    continue
+                for path in sorted(workspace.glob("*.jsonl"), key=lambda item: item.name):
+                    if path.is_file() and not path.is_symlink():
+                        yield path
+
+    @staticmethod
+    def _is_quick_ask(path: Path) -> bool:
+        marker = path.with_name(f"{path.stem}.quickask")
+        try:
+            return marker.exists()
+        except OSError:
+            return False
+
+    @classmethod
+    def _candidate_from_file(
+        cls,
+        path: Path,
+        cwd: str,
+        *,
+        require_cwd: bool,
+    ) -> dict[str, Any] | None:
+        if (
+            not path.is_file()
+            or path.is_symlink()
+            or path.suffix != ".jsonl"
+            or cls._is_quick_ask(path)
+        ):
+            return None
+        try:
+            records, _malformed = core._read_plain_jsonl(path)
+        except core.ReaderError:
+            return None
+        meta = _read_json_optional(path.with_name(f"{path.stem}.meta.json")) or {}
+        info = _workbuddy_session_info(records)
+        if not info["has_turn"]:
+            return None
+        actual_cwd = info["cwd"]
+        if not actual_cwd:
+            meta_cwd = meta.get("cwd")
+            actual_cwd = meta_cwd if isinstance(meta_cwd, str) else None
+        if require_cwd and not _same_cwd(actual_cwd, cwd):
+            return None
+        created_ms = core._timestamp_to_millis(meta.get("createdAt")) or info["first_ts"]
+        updated_ms = (
+            core._timestamp_to_millis(meta.get("updatedAt"))
+            or info["last_ts"]
+            or core._mtime_millis(path)
+        )
+        model = info["model"]
+        if not model:
+            meta_model = meta.get("model")
+            model = meta_model if isinstance(meta_model, str) else None
+        return {
+            "tool": "workbuddy",
+            "source": "workbuddy",
+            "session_id": core._safe_text(path.stem),
+            "path": str(path),
+            "title": info["title"],
+            "cwd": core._safe_text(actual_cwd) if actual_cwd else None,
+            "branch": None,
+            "created_at": core._iso_from_millis(created_ms),
+            "updated_at_ms": updated_ms,
+            "updated_at": core._iso_from_millis(updated_ms),
+            "source_repo_root_path": None,
+            "model": model,
+        }
+
+    def discover(self, cwd: str, within_min: int) -> list[dict[str, Any]]:
+        self.warnings = []
+        sessions: list[dict[str, Any]] = []
+        for path in self._files_for_cwd(cwd):
+            candidate = self._candidate_from_file(path, cwd, require_cwd=True)
+            if candidate is None:
+                continue
+            if core._within(int(candidate.get("updated_at_ms") or 0), within_min):
+                sessions.append(candidate)
+        return core._sort_and_dedupe(sessions)
+
+    def candidate_from_path(self, raw_path: str, cwd: str) -> dict[str, Any] | None:
+        path = Path(raw_path).expanduser()
+        if not path.exists() or path.is_symlink():
+            return None
+        return self._candidate_from_file(path, cwd, require_cwd=False)
+
+    def find_id(self, session_id: str, cwd: str) -> dict[str, Any] | None:
+        for path in self._files_for_cwd(cwd):
+            if path.stem.casefold() == session_id.casefold():
+                return self._candidate_from_file(path, cwd, require_cwd=False)
+        for path in self._all_files():
+            if path.stem.casefold() != session_id.casefold():
+                continue
+            return self._candidate_from_file(path, cwd, require_cwd=False)
+        return None
+
+    def read(self, candidate: dict[str, Any], max_tool_chars: int) -> dict[str, Any]:
+        path = Path(str(candidate["path"]))
+        records, malformed = core._read_plain_jsonl(path)
+        warnings: list[dict[str, str]] = []
+        turns: list[dict[str, Any]] = []
+        summaries: list[dict[str, Any]] = []
+        emitted_calls: set[str] = set()
+        emitted_results: set[str] = set()
+        hidden_thoughts = 0
+        filtered_records = 0
+        unknown_records = 0
+
+        corrupt_records = 0
+        for index, record in enumerate(records):
+            record_type = record.get("type")
+            if not isinstance(record_type, str):
+                corrupt_records += 1
+                continue
+            if record_type in _WORKBUDDY_CUSTOM_ITEM_TYPES:
+                if record_type == "summary":
+                    content = (
+                        record.get("summary")
+                        or record.get("text")
+                        or record.get("content")
+                    )
+                    if isinstance(content, str) and content.strip():
+                        summaries.append(
+                            {
+                                "kind": "summary",
+                                "content": core._safe_text(content),
+                                "inert": True,
+                            }
+                        )
+                continue
+            if record_type == "message":
+                role = record.get("role")
+                if _workbuddy_meta_record(record):
+                    filtered_records += 1
+                    continue
+                if role == "user":
+                    text = _workbuddy_user_text(record.get("content"))
+                    _workbuddy_append_turn(turns, "user", text)
+                elif role == "assistant":
+                    text = _workbuddy_assistant_text(record.get("content"))
+                    _workbuddy_append_turn(turns, "assistant", text)
+                else:
+                    filtered_records += 1
+            elif record_type == "reasoning":
+                hidden_thoughts += 1
+            elif record_type == "function_call":
+                call_id = _workbuddy_call_id(record, index)
+                if call_id in emitted_calls:
+                    continue
+                emitted_calls.add(call_id)
+                name = record.get("name")
+                turns.append(
+                    core._turn(
+                        "assistant",
+                        tool_calls=[
+                            {
+                                "id": core._safe_text(call_id),
+                                "name": core._safe_text(name) if name else "workbuddy_tool",
+                                "input": core._json_preview(
+                                    record.get("arguments") or {},
+                                    max_tool_chars,
+                                ),
+                                "inert": True,
+                            }
+                        ],
+                    )
+                )
+            elif record_type in {"function_call_result", "function_call_output"}:
+                call_id = _workbuddy_call_id(record, index)
+                if call_id in emitted_results:
+                    continue
+                emitted_results.add(call_id)
+                turns.append(
+                    core._turn(
+                        "tool",
+                        tool_results=[
+                            {
+                                "tool_use_id": core._safe_text(call_id),
+                                "content": _workbuddy_result_content(
+                                    record,
+                                    max_tool_chars,
+                                ),
+                                "is_error": _workbuddy_result_is_error(record),
+                                "unavailable": False,
+                                "inert": True,
+                            }
+                        ],
+                    )
+                )
+            else:
+                unknown_records += 1
+
+        if corrupt_records:
+            core._add_warning(
+                warnings,
+                "corrupt_records_skipped",
+                f"Skipped {corrupt_records} WorkBuddy record(s) whose type was not a string.",
+            )
+        if malformed:
+            core._add_warning(
+                warnings,
+                "malformed_records_skipped",
+                f"Skipped {malformed} malformed WorkBuddy record(s).",
+            )
+        if hidden_thoughts:
+            core._add_warning(
+                warnings,
+                "hidden_reasoning_skipped",
+                f"Excluded {hidden_thoughts} WorkBuddy reasoning record(s).",
+            )
+        if filtered_records:
+            core._add_warning(
+                warnings,
+                "internal_records_skipped",
+                f"Excluded {filtered_records} WorkBuddy internal or meta record(s).",
+            )
+        if hidden_thoughts or filtered_records:
+            core._add_warning(
+                warnings,
+                "unsafe_records_skipped",
+                "WorkBuddy hidden-reasoning or internal records were excluded from inert history.",
+            )
+        if unknown_records:
+            core._add_warning(
+                warnings,
+                "unknown_records_skipped",
+                f"Skipped {unknown_records} unsupported WorkBuddy record(s).",
+            )
+
+        result = {
+            "tool": "workbuddy",
+            "source": "workbuddy",
+            "session_id": candidate.get("session_id"),
+            "path": str(path),
+            "title": candidate.get("title"),
+            "cwd": candidate.get("cwd"),
+            "branch": None,
+            "created_at": candidate.get("created_at"),
+            "updated_at": candidate.get("updated_at"),
+            "source_repo_root_path": None,
+            "model": candidate.get("model"),
+            "turns": turns,
+            "summaries": summaries,
+            "warnings": warnings,
+        }
+        return _redact_output(core._finalize_result(result))
+
+
+def _workbuddy_assistant_text(content: Any) -> str:
+    parts: list[str] = []
+    for block in core._blocks(content):
+        block_type = block.get("type")
+        if isinstance(block_type, str) and block_type in {"output_text", "text"}:
+            text = block.get("text")
+            if isinstance(text, str) and text:
+                parts.append(text)
+    return core._safe_text("\n".join(parts))
+
+
 ADAPTERS: dict[str, ProviderAdapter] = {
     "grok": GrokAdapter(),
     "pi": PiAdapter(),
+    "qoder": QoderAdapter(),
+    "workbuddy": WorkBuddyAdapter(),
     "zcode": ZCodeAdapter(),
 }