thread-archive 0.0.2__py3-none-any.whl

thread_archive/_importers/claude_code.py

@@ -0,0 +1,293 @@
+"""Claude Code incremental import.
+
+Reduced to the conversation-archive essentials and run as a single atomic
+transaction. The watermark logic lives in :mod:`._cursor`: a content digest proves the
+file was only appended to, and the line cursor (``new_lines = all_lines[start_line:]``)
+then feeds just the grown tail into the importer — a source rewritten under the cursor
+rewinds and re-imports whole instead. Idempotence across re-reads (and across a
+rewind) is guaranteed by the dedup_key membership check in :func:`import_lines`.
+
+**Atomicity:** the whole import — thread create, events, watermark — commits in one
+session, so "the watermark advances only after a successful import" holds by
+construction.
+
+Deferred (enhancements, not core): compaction continuation/fork detection, subagent
+session handling, sidecar hook context, batch-thread adoption, description/models
+backfill, and rich title extraction.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import replace
+from pathlib import Path
+from typing import Any, Optional
+
+from thread_archive._thread_import import DefaultEventBuilder
+from thread_archive._thread_import.parsers.claude_code import ClaudeCodeParser
+
+from .._store import Thread, get_session
+from ._continuation import resolve_continuation_thread
+from ._cursor import resolve_source_cursor
+from ._events import import_lines
+from ._read import parse_session_lines, read_source_bytes
+from ._result import IncrementalImportResult
+from ._sidecar import import_sidecar_lines, read_sidecar_lines
+from ._state import (
+    adopt_if_unwatermarked,
+    create_thread,
+    discard_new_thread,
+    get_import_state,
+    get_thread_by_source,
+    lookup_parent_thread,
+    set_thread_models_from_events,
+    update_thread_description,
+    update_thread_title,
+    upsert_import_state,
+)
+from ._titles import extract_description, extract_session_title, extract_title
+
+logger = logging.getLogger(__name__)
+
+SOURCE = "claude-code"
+
+
+def _is_subagent_source_id(source_id: str) -> bool:
+    """True when this CC source_id names a Task-tool subagent transcript.
+
+    The watcher hands subagent files (``<project>/<uuid>/subagents/agent-*.jsonl``)
+    the same ``{project}:{stem}`` source_id as any other session; the stem keeps
+    Claude Code's ``agent-`` prefix, which is the marker that survives into the
+    import path. Subagent runs file as hidden ``thread_type='system'`` threads —
+    captured and searchable, but kept out of the archive sidebar."""
+    return source_id.rsplit(":", 1)[-1].startswith("agent-")
+
+
+def _cc_origin_metadata(all_lines: list[dict], source_id: str, *, session=None) -> Optional[dict]:
+    """Origin-project metadata for a CC thread: the real ``cwd`` (first line that
+    carries one) + the munged ``project_dir`` from the source_id.
+
+    For a subagent transcript also stamp ``is_subagent`` plus the spawning session
+    (``parent_session_id`` from the lines' ``sessionId``) and the subagent's own
+    ``agent_id`` (from ``agentId``), so the run can be joined back to its parent
+    thread. When a ``session`` is supplied and the parent resolves to no thread, the
+    gap is logged rather than lost silently."""
+    meta: dict[str, Any] = {}
+    for line in all_lines:
+        cwd = line.get("cwd")
+        if isinstance(cwd, str) and cwd:
+            meta["cwd"] = cwd
+            break
+    if ":" in source_id:
+        meta["project_dir"] = source_id.rsplit(":", 1)[0]
+    if _is_subagent_source_id(source_id):
+        meta["is_subagent"] = True
+        for line in all_lines:
+            if "agent_id" not in meta and line.get("agentId"):
+                meta["agent_id"] = line["agentId"]
+            if "parent_session_id" not in meta and line.get("sessionId"):
+                meta["parent_session_id"] = line["sessionId"]
+            if "agent_id" in meta and "parent_session_id" in meta:
+                break
+        parent_sid = meta.get("parent_session_id")
+        project_dir = meta.get("project_dir")
+        if session is not None and parent_sid and project_dir:
+            parent_source_id = f"{project_dir}:{parent_sid}"
+            if lookup_parent_thread(session, parent_source_id) is None:
+                logger.warning(
+                    "Subagent %s: parent_session_id %s resolves to no thread (%s) — "
+                    "run can't be joined back to its parent",
+                    source_id, parent_sid, parent_source_id,
+                )
+    return meta or None
+
+
+def _import_cc(
+    session,
+    source_id: str,
+    all_lines: list[dict],
+    source_bytes: bytes,
+    parser: ClaudeCodeParser,
+    builder: DefaultEventBuilder,
+    *,
+    source: str = SOURCE,
+    title_override: Optional[str] = None,
+) -> IncrementalImportResult:
+    import_state = get_import_state(session, source, source_id)
+    cursor = resolve_source_cursor(import_state, source_bytes, source=source, source_id=source_id)
+    current_file_size = len(source_bytes)
+
+    if cursor.unchanged and import_state:
+        # Byte-identical to the last import. Stamp the digest if this watermark predates
+        # it, so the next poll's append proof has something to check against.
+        import_state.last_content_hash = cursor.content_hash
+        return IncrementalImportResult(
+            lines_processed=0,
+            events_created=0,
+            thread_id=import_state.thread_id or 0,
+            is_new_thread=False,
+            last_message_uuid=import_state.last_message_uuid,
+        )
+
+    total_lines = len(all_lines)
+    start_line = cursor.start_line
+    if start_line >= total_lines:
+        # The file changed but yielded no new parsed lines (a torn tail line the writer
+        # hasn't finished; a rewrite down to nothing). Advance size + digest so the
+        # completed line still reads as an append next poll — the line cursor tracks
+        # what actually parsed, so the line itself imports then.
+        if import_state:
+            import_state.last_line_count = total_lines
+            import_state.last_file_size = current_file_size
+            import_state.last_content_hash = cursor.content_hash
+        return IncrementalImportResult(
+            lines_processed=0,
+            events_created=0,
+            thread_id=(import_state.thread_id or 0) if import_state else 0,
+            is_new_thread=False,
+            last_message_uuid=import_state.last_message_uuid if import_state else None,
+        )
+
+    new_lines = all_lines[start_line:]
+
+    # Resolve the thread: the watermark's thread_id wins, else lookup by source.
+    thread_id: Optional[int] = (
+        import_state.thread_id if (import_state and import_state.thread_id) else None
+    )
+    if thread_id is None:
+        existing = get_thread_by_source(session, source, source_id)
+        thread_id = existing.id if existing else None
+
+    if import_state is None and adopt_if_unwatermarked(
+        session, source=source, source_id=source_id,
+        thread_id=thread_id, total_lines=total_lines, file_size=current_file_size,
+        content_hash=cursor.content_hash,
+    ):
+        return IncrementalImportResult(0, 0, thread_id or 0, False, None)
+
+    is_subagent = _is_subagent_source_id(source_id)
+
+    # Continuation / fork merge: a fresh CC session that continues an existing thread
+    # (created on context compaction) merges into it instead of fragmenting into its
+    # own thread. Subagents are independent transcripts; cloth-shaped sources (source
+    # != "claude-code") don't carry CC's compaction markers, so both skip it.
+    merged_continuation = False
+    if thread_id is None and source == SOURCE and not is_subagent:
+        parent_id = resolve_continuation_thread(session, all_lines, source_id, parser, builder)
+        if parent_id is not None:
+            thread_id = parent_id
+            merged_continuation = True
+
+    is_new_thread = False
+    if thread_id is None:
+        title = title_override or extract_title(all_lines)
+        if is_subagent:
+            title = f"🤖 {title}"
+        thread_id = create_thread(
+            session,
+            source=source,
+            source_id=source_id,
+            title=title,
+            thread_type="system" if is_subagent else "conversation",
+            description=extract_description(all_lines),
+            source_metadata=_cc_origin_metadata(all_lines, source_id, session=session),
+        )
+        is_new_thread = True
+
+    events_created, last_uuid = import_lines(
+        session, thread_id, new_lines, parser, builder,
+        source=source, source_id=source_id, cross_pass_dedup=merged_continuation,
+    )
+
+    # A freshly-created thread that imported nothing (no importable content) is
+    # cleaned up so we don't leave an empty thread behind — row AND staged truth
+    # record, so no ghost threads/<id>.jsonl survives the commit.
+    if is_new_thread and events_created == 0:
+        discard_new_thread(session, thread_id)
+        thread_id = 0
+        is_new_thread = False
+    elif thread_id and events_created:
+        # Keep metadata current. New threads already carry title/description from
+        # create; an existing thread re-syncs a rename / AI title and backfills a
+        # missing description. Models are re-derived from the (now-written) events
+        # for both, so the sidebar model filter stays current.
+        if not is_new_thread:
+            refreshed = extract_session_title(all_lines)
+            if refreshed:
+                update_thread_title(session, thread_id, refreshed[:100])
+            thread = session.get(Thread, thread_id)
+            if thread is not None and not thread.description:
+                desc = extract_description(all_lines)
+                if desc:
+                    update_thread_description(session, thread_id, desc)
+        set_thread_models_from_events(session, thread_id)
+
+    upsert_import_state(
+        session,
+        source=source,
+        source_id=source_id,
+        thread_id=thread_id or None,
+        last_line_count=total_lines,
+        last_file_size=current_file_size,
+        last_content_hash=cursor.content_hash,
+        last_message_uuid=last_uuid,
+    )
+
+    return IncrementalImportResult(
+        lines_processed=len(new_lines),
+        events_created=events_created,
+        thread_id=thread_id or 0,
+        is_new_thread=is_new_thread,
+        last_message_uuid=last_uuid,
+    )
+
+
+def import_session_incremental(
+    session_path,
+    source_id: str,
+    parser: Optional[ClaudeCodeParser] = None,
+    builder: Optional[DefaultEventBuilder] = None,
+    *,
+    source: str = SOURCE,
+    session=None,
+) -> IncrementalImportResult:
+    """Import a Claude Code JSONL transcript incrementally.
+
+    Reads the file, then runs the import. When ``session`` is given the caller owns
+    the transaction; otherwise the whole import commits atomically in a fresh
+    session (so events + watermark land together, or not at all).
+
+    ``source`` is the thread/import-state source label. It defaults to
+    ``"claude-code"`` and is rarely overridden — the one case is a *host store that
+    writes Claude-Code-shaped JSONL under a different identity* (e.g. cloth's CLI
+    transcripts), which a deployment watcher imports under its own source so the
+    threads carry the right provenance rather than masquerading as claude-code.
+    """
+    session_path = Path(session_path)
+    if not session_path.exists():
+        raise FileNotFoundError(f"Session file not found: {session_path}")
+
+    parser = parser or ClaudeCodeParser()
+    builder = builder or DefaultEventBuilder()
+    source_bytes = read_source_bytes(session_path)
+    all_lines = parse_session_lines(source_bytes, session_path.name)
+    sidecar_lines = read_sidecar_lines(session_path)
+
+    def _run(s) -> IncrementalImportResult:
+        result = _import_cc(s, source_id, all_lines, source_bytes, parser, builder, source=source)
+        # The hook-context sidecar has its own line-count cursor, independent of the
+        # session file's size watermark — so a grown sidecar imports even when the
+        # main file is unchanged (and _import_cc returned early).
+        if result.thread_id and sidecar_lines:
+            n = import_sidecar_lines(s, result.thread_id, source_id, sidecar_lines)
+            if n:
+                result = replace(result, events_created=result.events_created + n)
+        return result
+
+    if session is not None:
+        return _run(session)
+
+    with get_session() as s:
+        result = _run(s)
+        s.commit()
+        return result

thread_archive/_importers/claude_science.py

@@ -0,0 +1,330 @@
+"""Claude Science (the Anthropic *AI Workbench* desktop app) session import.
+
+Claude Science keeps each org's work in a single live SQLite DB at
+``~/.claude-science/orgs/<org>/operon-cli.db``. A conversation is a **frame** (the
+``frames`` table): a root frame (``parent_frame_id IS NULL``) is a top-level chat,
+and a child frame is a subagent run (e.g. a ``REVIEWER`` spawned by the main
+``OPERON`` agent). A frame's transcript is its ``frame_messages`` rows — one
+Anthropic-shaped message per ``(frame_id, idx)`` in ``msg_json``
+(``{"role", "content": [blocks]}`` where a block is text / thinking / tool_use /
+tool_result / image).
+
+We scan the DB the way the Cursor / OpenCode importers do (open read-only, walk the
+conversations, incremental-skip via the import_state cursor), but a frame's messages
+are *already* Claude-shaped — so rather than re-deriving the NormalizedMessage blocks
+by hand, we synthesize Claude-Code-style JSONL lines from them and run them through
+the standard CC import path under ``source="claude-science"`` (exactly as cowork does
+for its ``audit.jsonl``). Continuation detection is CC-only, so it's skipped.
+
+Two store quirks shape the mapping:
+
+- **No per-message timestamp.** ``frame_messages`` carries none — only the frame has
+  ``created_at`` / ``completed_at``. So we stamp each message a deterministic
+  ``created_at + idx·STEP`` (see :func:`_synthesize_line`): monotonic by ``idx`` and
+  stable across incremental passes (``idx`` and ``created_at`` don't move), which is
+  what the event assembler needs. dedup is timestamp-free (content-keyed), so this
+  affects only ordering, never idempotence.
+- **Subagent frames.** A child frame (it has a ``parent_frame_id``) imports as a
+  hidden ``thread_type="system"`` thread with a 🤖-prefixed title, mirroring how CC
+  Task-tool subagents are filed.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sqlite3
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+from thread_archive._thread_import import DefaultEventBuilder
+from thread_archive._thread_import.parsers.claude_code import ClaudeCodeParser
+
+from .._store import get_session
+from ._events import import_lines
+from ._state import (
+    adopt_if_unwatermarked,
+    create_thread,
+    discard_new_thread,
+    get_import_state,
+    get_thread_by_source,
+    set_thread_models_from_events,
+    upsert_import_state,
+)
+from ._titles import extract_title
+
+logger = logging.getLogger(__name__)
+
+SOURCE = "claude-science"
+
+# Synthetic per-message spacing (ms). The store records no per-message time, so we
+# space messages a second apart from the frame's start — monotonic and stable per
+# ``idx``, which is all the assembler's ordering needs.
+_STEP_MS = 1000
+
+# Frames that aren't conversations: the per-project "User Uploads" container.
+_NON_CONVERSATION_TYPES = ("uploads",)
+
+# Anthropic ships a demo project ("Example project", id ``proj_example``) of pre-built
+# analyses — scRNA-seq, CRISPR, phylogenetics — seeded into every install. Those are
+# *Anthropic's* canned transcripts, not the user's own work, so they're kept out of
+# the archive (importing them would inject fabricated "science you did" threads). The
+# user's real frames live under their own ``proj_<hash>`` ids and import normally.
+_SEEDED_PROJECT_IDS = ("proj_example",)
+
+
+@dataclass
+class ClaudeScienceImportResult:
+    events_created: int
+    thread_id: int
+    is_new_thread: bool
+
+
+@dataclass
+class ClaudeScienceDbScanResult:
+    frames_processed: int
+    frames_imported: int
+    events_created: int
+    frames_failed: int = 0
+    errors: list[str] = field(default_factory=list)
+
+
+def _iso_from_ms(ms: int) -> str:
+    return datetime.fromtimestamp(ms / 1000, tz=timezone.utc).isoformat()
+
+
+def _synthesize_line(frame_id: str, idx: int, msg: dict, model: Optional[str], base_ms: int) -> Optional[dict]:
+    """Turn one ``frame_messages`` row into a Claude-Code-shaped JSONL line.
+
+    The message body (``role`` + ``content`` blocks) is already Anthropic-shaped, so
+    it drops straight into the CC line's ``message`` field; we only add the envelope
+    (``type`` / ``uuid`` / synthetic ``timestamp`` / ``sessionId``) the parser keys
+    off. A real ``_uuid`` is used when present so re-imports dedup on a stable id;
+    otherwise ``{frame_id}:{idx}`` is a stable synthetic stand-in."""
+    role = msg.get("role")
+    if role not in ("user", "assistant"):
+        return None
+    content = msg.get("content")
+    if content is None:
+        return None
+    message: dict[str, Any] = {"role": role, "content": content}
+    if role == "assistant" and model:
+        message["model"] = model
+    return {
+        "type": role,
+        "uuid": msg.get("_uuid") or f"{frame_id}:{idx}",
+        "timestamp": _iso_from_ms(base_ms + idx * _STEP_MS),
+        "sessionId": frame_id,
+        "message": message,
+    }
+
+
+def _frame_title(frame: dict, lines: list[dict]) -> str:
+    """A thread title for a frame: its ``name`` (what the app shows), else its
+    ``task_summary``, else the first-user-message fallback. A child (subagent) frame
+    gets a 🤖 prefix. Onboarding/system-prefixed first lines fall back to an
+    agent-named label rather than leaking the injected ``[System]`` block."""
+    title = (frame.get("name") or "").strip() or (frame.get("task_summary") or "").strip()
+    if not title:
+        derived = extract_title(lines)
+        if derived and derived != "Claude Code Session" and not derived.startswith("[System]"):
+            title = derived
+        else:
+            agent = (frame.get("agent_name") or "").strip().replace("_", " ").title()
+            title = f"{agent} Session" if agent else "Claude Science Session"
+    if frame.get("parent_frame_id"):
+        title = f"🤖 {title}"
+    return title[:100]
+
+
+def _frame_metadata(org_uuid: str, frame: dict) -> dict:
+    """Origin metadata for a Claude Science thread — the org, the frame's identity in
+    the app, and (for a subagent) the parent/root frame it was spawned under."""
+    meta: dict[str, Any] = {
+        "app": "claude-science",
+        "org_uuid": org_uuid,
+        "frame_id": frame.get("id"),
+        "agent_name": frame.get("agent_name"),
+        "conversation_type": frame.get("conversation_type"),
+        "project_id": frame.get("project_id"),
+        "model": frame.get("model"),
+    }
+    if frame.get("parent_frame_id"):
+        meta["is_subagent"] = True
+        meta["parent_frame_id"] = frame.get("parent_frame_id")
+        meta["root_frame_id"] = frame.get("root_frame_id")
+    return {k: v for k, v in meta.items() if v is not None}
+
+
+def _run_frame(
+    session,
+    org_uuid: str,
+    frame: dict,
+    message_rows: list,
+    parser: ClaudeCodeParser,
+    builder: DefaultEventBuilder,
+) -> ClaudeScienceImportResult:
+    frame_id = frame["id"]
+    source_id = f"{org_uuid}:{frame_id}"
+    import_state = get_import_state(session, SOURCE, source_id)
+
+    total = len(message_rows)
+    start = import_state.last_line_count if import_state else 0
+    if import_state and start >= total:
+        return ClaudeScienceImportResult(0, import_state.thread_id or 0, False)
+
+    base_ms = int(frame.get("created_at") or 0)
+    model = frame.get("model")
+    lines: list[dict] = []
+    for row in message_rows:
+        idx, raw = row[0], row[1]
+        try:
+            msg = json.loads(raw)
+        except (json.JSONDecodeError, TypeError):
+            continue
+        if not isinstance(msg, dict):
+            continue
+        line = _synthesize_line(frame_id, idx, msg, model, base_ms)
+        if line is not None:
+            lines.append(line)
+
+    # Resolve the thread (watermark wins, else lookup by source) before any create.
+    thread_id: Optional[int] = (
+        import_state.thread_id if (import_state and import_state.thread_id) else None
+    )
+    if thread_id is None:
+        existing = get_thread_by_source(session, SOURCE, source_id)
+        thread_id = existing.id if existing else None
+
+    # Reindex safety: a thread with events but no watermark (cursor lost to a
+    # `rm index.db && reindex`) is adopted at EOF rather than re-imported from 0.
+    if import_state is None and adopt_if_unwatermarked(
+        session, source=SOURCE, source_id=source_id,
+        thread_id=thread_id, total_lines=total, file_size=0,
+    ):
+        return ClaudeScienceImportResult(0, thread_id or 0, False)
+
+    is_new_thread = False
+    if thread_id is None:
+        thread_id = create_thread(
+            session,
+            source=SOURCE,
+            source_id=source_id,
+            title=_frame_title(frame, lines),
+            thread_type="system" if frame.get("parent_frame_id") else "conversation",
+            source_metadata=_frame_metadata(org_uuid, frame),
+        )
+        is_new_thread = True
+
+    new_lines = lines[start:]
+    events_created, last_uuid = import_lines(
+        session, thread_id, new_lines, parser, builder, source=SOURCE, source_id=source_id,
+    )
+
+    # A freshly-created thread that imported nothing (no importable content) is
+    # cleaned up so we don't leave an empty thread behind — row AND staged truth
+    # record, so no ghost threads/<id>.jsonl survives the commit.
+    if is_new_thread and events_created == 0:
+        discard_new_thread(session, thread_id)
+        thread_id = 0
+        is_new_thread = False
+    elif thread_id and events_created:
+        set_thread_models_from_events(session, thread_id)
+
+    upsert_import_state(
+        session,
+        source=SOURCE,
+        source_id=source_id,
+        thread_id=thread_id or None,
+        last_line_count=total,
+        last_file_size=0,
+        last_message_uuid=last_uuid,
+    )
+    return ClaudeScienceImportResult(events_created, thread_id or 0, is_new_thread)
+
+
+def import_claude_science_frame(
+    org_uuid: str,
+    frame: dict,
+    message_rows: list,
+    parser: Optional[ClaudeCodeParser] = None,
+    builder: Optional[DefaultEventBuilder] = None,
+    *,
+    session=None,
+) -> ClaudeScienceImportResult:
+    """Import one frame's transcript (atomic per-frame transaction when no session)."""
+    parser = parser or ClaudeCodeParser()
+    builder = builder or DefaultEventBuilder()
+    if session is not None:
+        return _run_frame(session, org_uuid, frame, message_rows, parser, builder)
+    with get_session() as s:
+        result = _run_frame(s, org_uuid, frame, message_rows, parser, builder)
+        s.commit()
+        return result
+
+
+# The frame columns the importer reads (title/metadata/timestamps + identity).
+_FRAME_COLUMNS = (
+    "id", "parent_frame_id", "root_frame_id", "agent_name", "conversation_type",
+    "name", "task_summary", "model", "project_id", "created_at",
+)
+
+
+def import_claude_science_db(db_path, org_uuid: str) -> ClaudeScienceDbScanResult:
+    """Open a Claude Science ``operon-cli.db`` (read-only) and import every frame in
+    it under ``org_uuid``. The DB is live, so we open it ``mode=ro`` with a busy
+    timeout and never write to it."""
+    db_path = Path(db_path)
+    summary = ClaudeScienceDbScanResult(0, 0, 0)
+    parser = ClaudeCodeParser()
+    builder = DefaultEventBuilder()
+
+    conn = sqlite3.connect(f"file:{db_path}?mode=ro", uri=True)
+    try:
+        conn.execute("PRAGMA busy_timeout=5000")
+        if not conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name='frames'"
+        ).fetchone():
+            return summary
+
+        type_ph = ", ".join("?" for _ in _NON_CONVERSATION_TYPES)
+        proj_ph = ", ".join("?" for _ in _SEEDED_PROJECT_IDS)
+        frames = conn.execute(
+            f"SELECT {', '.join(_FRAME_COLUMNS)} FROM frames "
+            f"WHERE conversation_type NOT IN ({type_ph}) "
+            f"  AND (project_id IS NULL OR project_id NOT IN ({proj_ph})) "
+            f"ORDER BY created_at",
+            (*_NON_CONVERSATION_TYPES, *_SEEDED_PROJECT_IDS),
+        ).fetchall()
+
+        for frame_row in frames:
+            frame = dict(zip(_FRAME_COLUMNS, frame_row))
+            frame_id = frame["id"]
+            message_rows = conn.execute(
+                "SELECT idx, msg_json FROM frame_messages WHERE frame_id = ? ORDER BY idx",
+                (frame_id,),
+            ).fetchall()
+            if not message_rows:
+                continue
+            summary.frames_processed += 1
+            try:
+                result = import_claude_science_frame(
+                    org_uuid, frame, message_rows, parser, builder
+                )
+                if result.events_created > 0:
+                    summary.frames_imported += 1
+                    summary.events_created += result.events_created
+            except Exception as e:  # noqa: BLE001 — one bad frame must not stop the scan
+                # Counted out to the watcher, not just logged — see the same guard in
+                # opencode: a silently-skipped frame reads as "nothing new" and leaves
+                # `archive status` green while a conversation is missing.
+                logger.exception(
+                    "import_claude_science_db: frame %s failed; skipping", frame_id[:8]
+                )
+                summary.frames_failed += 1
+                summary.errors.append(f"frame {frame_id[:8]}: {e}")
+    finally:
+        conn.close()
+    return summary

thread_archive/_importers/cloth.py

@@ -0,0 +1,20 @@
+"""cloth session import — cloth is a Claude-Code-shaped terminal harness.
+
+cloth writes the same per-session JSONL shape as Claude Code (``user`` / ``assistant``
+lines, plus a ``cloth_meta`` line the parser harmlessly ignores), so its importer
+**delegates to the claude_code line-stream import** under ``source="cloth"`` rather
+than duplicating a parser. Threads land with ``source="cloth"`` and ``source_id`` set
+to the bare session-file stem (the CLI's session uuid — already globally unique — so
+no prefix; see ``watcher.sources.cloth_watcher``). Idempotence, the truth-log seam, and
+incremental watermarking all come from the shared claude_code path unchanged.
+"""
+
+from __future__ import annotations
+
+from ._result import IncrementalImportResult
+from .claude_code import import_session_incremental
+
+
+def import_cloth_session_incremental(session_path, source_id: str, *, session=None) -> IncrementalImportResult:
+    """Import one cloth CLI transcript into the event log, under ``source="cloth"``."""
+    return import_session_incremental(session_path, source_id, source="cloth", session=session)