elliot-stack 1.0.38 → 1.0.40

package/skills/estack-read-claude-session-history/scripts/read_transcript.py

@@ -33,6 +33,16 @@ from lib import search as S  # noqa: E402
 from lib import subagents as SA  # noqa: E402
 
 
+# Wide-scope search output budget. Full match windows across many sessions can
+# balloon past the harness's ~25k-token Read cap, forcing a write-then-can't-read
+# round trip. We summarize by default and degrade --full back to a summary once
+# the rendered text would exceed this many characters (~10k tokens at ~4 ch/tok).
+SEARCH_CHAR_BUDGET = 40_000
+# Cap session lines in the summary view so the summary itself stays bounded.
+# Overflow is counted and noted, never silently dropped.
+SEARCH_SUMMARY_SESSION_CAP = 200
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Legacy mode implementations (kept byte-identical to v1 for backwards-compat)
 # ─────────────────────────────────────────────────────────────────────────────
@@ -107,24 +117,6 @@ def mode_dump(lines, limit=80):
     return "\n\n".join(output)
 
 
-def mode_search_legacy(lines, query: str):
-    """Legacy single-file search: assistant text only, case-insensitive."""
-    messages = PR.get_messages(lines)
-    results = []
-    q = query.lower()
-    for m in messages:
-        if m["role"] == "assistant":
-            combined = " ".join(m["texts"])
-            if q in combined.lower():
-                results.append(combined)
-    if not results:
-        return None
-    output = [f"=== {len(results)} match(es) for '{query}' ===\n"]
-    for i, r in enumerate(results, 1):
-        output.append(f"--- Match #{i} ---\n{r[:1500]}")
-    return "\n\n".join(output)
-
-
 def mode_debug(lines):
     output = []
     type_counts: dict[str, int] = {}
@@ -579,6 +571,81 @@ def mode_tool_calls(path: Path, tool_filter: set[str] | None, fmt: str = "text")
     return "\n".join(out).lstrip("\n")
 
 
+def _one_line(text: str, n: int) -> str:
+    """Collapse whitespace to a single line and truncate to n chars."""
+    s = " ".join((text or "").split())
+    return s[:n] + ("…" if len(s) > n else "")
+
+
+def _sessions_by_mtime(matches) -> list:
+    """Group matches by session, return (session_path, matches) sorted newest first."""
+    by_session: dict[Path, list] = {}
+    for m in matches:
+        by_session.setdefault(m.session_path, []).append(m)
+    return sorted(by_session.items(), key=lambda kv: kv[1][0].mtime, reverse=True)
+
+
+def _render_search_full(matches) -> str:
+    """Full per-match windows grouped by session, newest first (the detailed view)."""
+    out = []
+    for sp, ms in _sessions_by_mtime(matches):
+        out.append(f"{'=' * 60}\nSession: {sp.name}  ({_fmt_mtime(ms[0].mtime)})\n{'=' * 60}")
+        for i, m in enumerate(ms, 1):
+            label = f"--- Match #{i} [{m.role}/{m.where}] ---"
+            out.append(f"{label}\n{m.window_text[:1500]}")
+    return "\n\n".join(out)
+
+
+def _render_search_summary(query: str, matches, already_full: bool = False) -> str:
+    """One line per session: mtime · uuid8 · project · hits · first snippet.
+
+    Every hit is counted in the header; sessions past the cap are counted in a
+    footer note, never silently dropped. When ``already_full`` is set (the
+    summary is a degraded ``--full`` result), the footer drops the "use --full"
+    suggestion the caller already tried.
+    """
+    sessions = _sessions_by_mtime(matches)
+    total_hits = len(matches)
+    total_sessions = len(sessions)
+    shown = sessions[:SEARCH_SUMMARY_SESSION_CAP]
+    hit_w = "match" if total_hits == 1 else "matches"
+    sess_w = "session" if total_sessions == 1 else "sessions"
+    lines = [f'=== "{query}": {total_hits} {hit_w} across {total_sessions} {sess_w} ===']
+    for sp, ms in shown:
+        uuid8 = sp.stem[:8]
+        project = P.decode_project_name(sp.parent.name)
+        snippet = _one_line(ms[0].window_text, 120)
+        n = len(ms)
+        # Pad the unit so singular ("hit ") and plural ("hits") align the snippet column.
+        hits = f'{n:>4} hit' + ('s' if n != 1 else ' ')
+        lines.append(f'{_fmt_mtime(ms[0].mtime)}  {uuid8}  {project[:28]:<28}  {hits}  · "{snippet}"')
+    if total_sessions > len(shown):
+        lines.append(
+            f"… and {total_sessions - len(shown)} more session(s) not shown — "
+            f"narrow with --project or a tighter --query."
+        )
+    # On a degrade (already_full) the [note] prefix already carries the actionable
+    # hint, so don't append a second — possibly conflicting — guidance line.
+    if not already_full:
+        lines.append("Use --full for match windows, or narrow with --project / a tighter --query.")
+    return "\n".join(lines)
+
+
+def _search_summary_json(matches) -> list:
+    """Compact per-session metadata (no windows) for structured consumers."""
+    return [
+        {
+            "session": str(sp),
+            "uuid": sp.stem,
+            "project": P.decode_project_name(sp.parent.name),
+            "mtime_iso": _fmt_mtime(ms[0].mtime),
+            "hits": len(ms),
+            "first_snippet": _one_line(ms[0].window_text, 120),
+        }
+        for sp, ms in _sessions_by_mtime(matches)
+    ]
+
+
 def mode_search_v2(
     root: Path,
     cwd: str | None,
@@ -593,6 +660,7 @@ def mode_search_v2(
     fmt: str = "text",
     exclude_current: bool = False,
     current_uuid: str | None = None,
+    full: bool = False,
 ):
     """Cross-scope search with role/in-channel filters."""
     matches: list = []
@@ -607,12 +675,21 @@ def mode_search_v2(
         pd = P.find_project_dir(cwd, root)
         matches = list(S.search_project(pd, query, role, in_channel, since, until))
     else:
-        return "Provide --file, --cwd, --project, or --all-projects"
+        # Unreachable from the CLI (the dispatch guarantees a scope flag), but keep
+        # the direct-call contract honest: JSON callers get a JSON object.
+        msg = "Provide --file, --cwd, --project, or --all-projects"
+        return {"error": msg} if fmt == "json" else msg
 
     if exclude_current and current_uuid:
         matches = [m for m in matches if m.session_path.stem != current_uuid]
 
+    # Single-file scope is narrow and won't overflow — render full by default.
+    # Wide scope (cwd / project / all-projects) summarizes unless --full is set.
+    wide = file_path is None
+
     if fmt == "json":
+        if wide and not full:
+            return _search_summary_json(matches)
         return [
             {
                 "session": str(m.session_path),
@@ -628,17 +705,25 @@ def mode_search_v2(
     if not matches:
         return f"No matches for '{query}'."
 
-    # Group by session for readable output
-    by_session: dict[Path, list] = {}
-    for m in matches:
-        by_session.setdefault(m.session_path, []).append(m)
-    out = []
-    for sp, ms in by_session.items():
-        out.append(f"\n{'=' * 60}\nSession: {sp.name}  ({_fmt_mtime(ms[0].mtime)})\n{'=' * 60}")
-        for i, m in enumerate(ms, 1):
-            label = f"--- Match #{i} [{m.role}/{m.where}] ---"
-            out.append(f"{label}\n{m.window_text[:1500]}")
-    return "\n\n".join(out)
+    if wide and not full:
+        return _render_search_summary(query, matches)
+
+    # Full render (single-file, or wide + --full), bounded by the char budget so
+    # the output never exceeds what the reader accepts. Degrade to summary if it would.
+    full_text = _render_search_full(matches)
+    if len(full_text) > SEARCH_CHAR_BUDGET:
+        # Ceiling-round the size so it always reads as strictly over the budget.
+        size_k = (len(full_text) + 999) // 1000
+        if wide:
+            hint = "Use a tighter --query / --role / --in, or --file <session> to read one session in full."
+        else:
+            hint = "This one session has many matches; use a tighter --query / --role / --in to narrow."
+        note = (
+            f"[note: full output is ~{size_k}K chars (> "
+            f"{SEARCH_CHAR_BUDGET // 1000}K budget) — showing a summary instead. {hint}]"
+        )
+        return note + "\n" + _render_search_summary(query, matches, already_full=True)
+    return full_text
 
 
 def mode_subagent_list(path: Path, fmt: str = "text"):
@@ -774,9 +859,10 @@ def _tally_tool_usage(
                         continue
                     if ts.tzinfo is not None:
                         ts = ts.replace(tzinfo=None)
+                    # Half-open window [since, until): since inclusive, until exclusive.
                     if since is not None and ts < since:
                         continue
-                    if until is not None and ts > until:
+                    if until is not None and ts >= until:
                         continue
                 name = c["name"] or "(unknown)"
                 tool_counts[name] = tool_counts.get(name, 0) + 1
@@ -1116,17 +1202,38 @@ def _is_real_user_prompt(obj: dict) -> bool:
     return False
 
 
+def _assistant_has_text(obj: dict) -> bool:
+    """True if an assistant entry carries human-visible text, not just tool_use.
+
+    A turn that only fires tools (no text block) is plumbing, not a reply the
+    user reads, so it does not count as an assistant message.
+    """
+    content = obj.get("message", {}).get("content", "")
+    if isinstance(content, str):
+        return bool(content.strip())
+    if isinstance(content, list):
+        return any(
+            isinstance(b, dict) and b.get("type") == "text" and b.get("text", "").strip()
+            for b in content
+        )
+    return False
+
+
 def _engagement_event_streams(
     path: Path, since: datetime | None, until: datetime | None
-) -> tuple[list[datetime], list[datetime]]:
-    """One session's (user_events, claude_events) inside [since, until).
+) -> tuple[list[datetime], list[datetime], list[datetime]]:
+    """One session's (user_events, claude_events, assistant_events) in [since, until).
 
     user_events — real user prompts only (see _is_real_user_prompt).
     claude_events — assistant messages and tool results: evidence Claude was
     working. Used only to grant waiting-on-Claude credit for long gaps.
+    assistant_events — assistant turns bearing visible text (see
+    _assistant_has_text): the replies the user actually reads, counted clean of
+    tool-only turns and tool-result envelopes.
     """
     user_ev: list[datetime] = []
     claude_ev: list[datetime] = []
+    assistant_ev: list[datetime] = []
     for obj in PR.parse_lines(path):
         cls = PR.classify_entry(obj)
         if cls in ("noise", "title", "compact"):
@@ -1143,9 +1250,12 @@ def _engagement_event_streams(
                 claude_ev.append(ts)  # tool_result entries
         else:  # assistant
             claude_ev.append(ts)
+            if _assistant_has_text(obj):
+                assistant_ev.append(ts)
     user_ev.sort()
     claude_ev.sort()
-    return user_ev, claude_ev
+    assistant_ev.sort()
+    return user_ev, claude_ev, assistant_ev
 
 
 def build_engagement(
@@ -1179,6 +1289,7 @@ def build_engagement(
 
     user_events: dict[Path, list[datetime]] = {}
     claude_events: dict[Path, list[datetime]] = {}
+    assistant_events: dict[Path, list[datetime]] = {}
     walk_dirs = P.list_projects(root)
     files: list[Path] = []
     for pd in walk_dirs:
@@ -1193,10 +1304,11 @@ def build_engagement(
     for f in files:
         if exclude_current and current_uuid and f.stem == current_uuid:
             continue
-        u, c = _engagement_event_streams(f, since, until)
+        u, c, a = _engagement_event_streams(f, since, until)
         if u or c:
             user_events[f] = u
             claude_events[f] = c
+            assistant_events[f] = a
 
     stream = sorted(
         (ts, f) for f, evs in user_events.items() for ts in evs
@@ -1234,6 +1346,7 @@ def build_engagement(
             "first": evs[0],
             "last": evs[-1],
             "user_messages": len(evs),
+            "assistant_messages": len(assistant_events.get(f, [])),
             "active": active.get(f, timedelta()),
         }
 
@@ -1281,7 +1394,8 @@ def render_engagement(data: dict, tz_label: str) -> str:
             if elapsed.total_seconds() > 0 else "  — "
         )
         out.append(
-            f"{_fmt_dur(s['active']):>7}  ratio {ratio}  msgs {s['user_messages']:<4} "
+            f"{_fmt_dur(s['active']):>7}  ratio {ratio}  "
+            f"you {s['user_messages']:<3} ai {s['assistant_messages']:<4} "
             f"{s['first'].strftime(tfmt)}–{s['last'].strftime('%H:%M')}  "
             f"{_session_label(s['summary'])}"
         )
@@ -1308,7 +1422,7 @@ def render_engagement(data: dict, tz_label: str) -> str:
         (f, s), = sessions.items()
         # recompute the session's own user events from the stored bounds is not
         # enough — pull them again (cached parse, cheap)
-        evs, _ = _engagement_event_streams(f, data["since"], data["until"])
+        evs, _, _ = _engagement_event_streams(f, data["since"], data["until"])
         pct = _gap_percentiles(evs)
         if pct:
             out.append(f"Prompt gaps: median {pct[0]}m, p90 {pct[1]}m")
@@ -1346,6 +1460,7 @@ def engagement_json(data: dict) -> dict:
                 if elapsed.total_seconds() > 0 else None
             ),
             "user_messages": s["user_messages"],
+            "assistant_messages": s["assistant_messages"],
         })
     span_min = 0
     if data["sessions"]:
@@ -1374,6 +1489,102 @@ def engagement_json(data: dict) -> dict:
     }
 
 
+# ─────────────────────────────────────────────────────────────────────────────
+# Session-report mode — the per-session "what did I do" view
+# ─────────────────────────────────────────────────────────────────────────────
+# Reuses the engagement engine (windowed, overlap-safe attention time) but
+# renders one numbered block per session, chronological, with both clocks
+# (ran = own first→last span, which overlaps others; active = deduped
+# attention), per-role message counts, and the intent/last-message inputs a
+# human day-review is written from.
+
+def render_session_report(data: dict, tz_label: str) -> str:
+    since, until = data["since"], data["until"]
+    sessions = data["sessions"]
+    multi_day = (until - since) > timedelta(days=1)
+    tfmt = "%Y-%m-%d %H:%M" if multi_day else "%H:%M"
+    head = (
+        f"=== Session report {since:%Y-%m-%d %H:%M} → {until:%Y-%m-%d %H:%M} "
+        f"(times: {tz_label}, break={data['break_minutes']}m) ==="
+    )
+    if not sessions:
+        return head + "\n\n(no user activity in range)"
+    out = [head, ""]
+    rows = sorted(sessions.items(), key=lambda kv: kv[1]["first"])  # chronological
+    for i, (f, s) in enumerate(rows, 1):
+        summary = s["summary"]
+        elapsed = s["last"] - s["first"]
+        title = summary.get("title") or summary.get("first_prompt") or "(untitled)"
+        out.append(f"{i}. {title}")
+        out.append(
+            f"   {summary['decoded_project']}  ·  "
+            f"{s['first'].strftime(tfmt)}–{s['last'].strftime('%H:%M')}  "
+            f"(ran {_fmt_dur(elapsed)} · active {_fmt_dur(s['active'])})"
+        )
+        out.append(
+            f"   you {s['user_messages']} msgs · "
+            f"assistant {s['assistant_messages']} msgs · "
+            f"{summary['edit_count']} files edited"
+        )
+        out.append(f"   intent: {summary.get('first_prompt') or '(no user prompt)'}")
+        out.append(f"   last:   {summary.get('last_assistant') or '(no assistant message)'}")
+        out.append("")
+    total_active = sum((s["active"] for s in sessions.values()), timedelta())
+    first = min(s["first"] for s in sessions.values())
+    last = max(s["last"] for s in sessions.values())
+    out.append(
+        f"Total: {len(sessions)} session(s) · {_fmt_dur(total_active)} active "
+        f"(overlap removed) across a {_fmt_dur(last - first)} span "
+        f"({first.strftime(tfmt)}–{last.strftime('%H:%M')})."
+    )
+    out.append(
+        "(active = your attention, parallel chats never double-counted; "
+        "ran = each session's own first→last span, which can overlap others.)"
+    )
+    return "\n".join(out)
+
+
+def session_report_json(data: dict) -> dict:
+    rows = sorted(data["sessions"].items(), key=lambda kv: kv[1]["first"])
+    sessions_out = []
+    total_active = timedelta()
+    for f, s in rows:
+        summary = s["summary"]
+        elapsed = s["last"] - s["first"]
+        total_active += s["active"]
+        sessions_out.append({
+            "uuid": summary["uuid"],
+            "project": summary["decoded_project"],
+            "title": summary.get("title") or summary.get("first_prompt") or "",
+            "path": str(f),
+            "first": s["first"].isoformat(),
+            "last": s["last"].isoformat(),
+            "elapsed_minutes": int(elapsed.total_seconds() // 60),
+            "active_minutes": int(s["active"].total_seconds() // 60),
+            "user_messages": s["user_messages"],
+            "assistant_messages": s["assistant_messages"],
+            "edits": summary["edit_count"],
+            "intent": summary.get("first_prompt") or "",
+            "last_message": summary.get("last_assistant") or "",
+        })
+    span_min = 0
+    if data["sessions"]:
+        first = min(s["first"] for s in data["sessions"].values())
+        last = max(s["last"] for s in data["sessions"].values())
+        span_min = int((last - first).total_seconds() // 60)
+    return {
+        "since": data["since"].isoformat(),
+        "until": data["until"].isoformat(),
+        "break_minutes": data["break_minutes"],
+        "sessions": sessions_out,
+        "totals": {
+            "sessions": len(sessions_out),
+            "active_minutes": int(total_active.total_seconds() // 60),
+            "span_minutes": span_min,
+        },
+    }
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # JSON builders for legacy single-file modes
 # ─────────────────────────────────────────────────────────────────────────────
@@ -1466,6 +1677,7 @@ NEW_MODES = {
     "changelog", "file-edits", "tool-calls", "tool-usage",
     "subagent-list", "subagent-finals", "subagent-tools", "subagent-files",
     "resume-prev", "count", "journal", "diff", "timeline", "engagement",
+    "session-report",
 }
 
 ALL_MODES = LEGACY_MODES | NEW_MODES
@@ -1509,6 +1721,9 @@ def build_parser() -> argparse.ArgumentParser:
 
     # Mode-specific flags
     p.add_argument("--query", help="Search query (for search/count modes)")
+    p.add_argument("--full", action="store_true",
+                   help="Wide-scope search: expand to full match windows instead of "
+                        "the per-session summary (bounded; degrades back to summary if oversized)")
     p.add_argument("--uuid", help="UUID prefix (for lookup/resume-cmd modes)")
     p.add_argument("--title", help="Title substring (for find mode)")
     p.add_argument("--first-prompt", dest="first_prompt", help="First-prompt substring (for find mode)")
@@ -1590,40 +1805,6 @@ def main() -> int:
     since = _resolve_time(args.since)
     until = _resolve_time(args.until)
 
-    # Legacy --mode search with --cwd (no --file) preserved byte-for-byte.
-    if args.mode == "search" and args.cwd and not args.file and not args.all_projects \
-            and not args.project and fmt == "text" \
-            and args.role == "both" and args.in_channel == "text":
-        if not args.query:
-            print("--query required with --mode search", file=sys.stderr)
-            return 1
-        files = P.list_transcripts(P.find_project_dir(args.cwd, root))
-        if not files:
-            print("No transcript files found.")
-            return 0
-        total_matches = 0
-        for i, f in enumerate(files, 1):
-            print(f"Searching {i}/{len(files)}: {f.name}...", file=sys.stderr, end="\r")
-            try:
-                lines = PR.parse_lines(f)
-                result = mode_search_legacy(lines, args.query)
-            except Exception as e:
-                print(f"\nError reading {f.name}: {e}", file=sys.stderr)
-                continue
-            if result is not None:
-                mtime = _fmt_mtime(f.stat().st_mtime)
-                print(f"\n{'=' * 60}")
-                print(f"Session: {f.name}  ({mtime})")
-                print("=" * 60)
-                print(result)
-                total_matches += 1
-        print(file=sys.stderr)
-        if total_matches == 0:
-            print(f"No matches for '{args.query}' found across {len(files)} session(s).")
-        else:
-            print(f"\n--- Found matches in {total_matches}/{len(files)} session(s) ---")
-        return 0
-
     mode = args.mode
 
     # Discovery modes — don't need --file
@@ -1712,7 +1893,7 @@ def main() -> int:
         else:
             print(render_timeline(data, tz_label=args.tz or "local"))
         return 0
-    if mode == "engagement":
+    if mode in ("engagement", "session-report"):
         try:
             break_minutes = _parse_gap(args.break_spec, default=10)
             if args.date:
@@ -1731,7 +1912,7 @@ def main() -> int:
             return 1
         if report_file and e_since is None:
             # Window defaults to the file's own first→last user prompt.
-            evs, _ = _engagement_event_streams(report_file, None, None)
+            evs, _, _ = _engagement_event_streams(report_file, None, None)
             if not evs:
                 print("(no user messages in this session)")
                 return 0
@@ -1750,7 +1931,12 @@ def main() -> int:
             root, report_dirs, report_file, e_since, e_until, break_minutes,
             current_uuid, exclude_current=args.exclude_current,
         )
-        if fmt == "json":
+        if mode == "session-report":
+            if fmt == "json":
+                _print_json(session_report_json(data))
+            else:
+                print(render_session_report(data, tz_label=args.tz or "local"))
+        elif fmt == "json":
             _print_json(engagement_json(data))
         else:
             print(render_engagement(data, tz_label=args.tz or "local"))
@@ -1769,8 +1955,8 @@ def main() -> int:
             return 1
         _emit(mode_diff(Path(args.file_a), Path(args.file_b), fmt=fmt))
         return 0
-    # (cwd-scoped searches with non-default role/in/json land here — the
-    # byte-compat legacy path above already handled the default-flag case.)
+    # All scoped searches (--file / --cwd / --project / --all-projects) route here.
+    # Wide scope summarizes by default; --full expands to bounded match windows.
     if mode == "search" and (args.file or args.all_projects or args.project or args.cwd):
         if not args.query:
             print("--query required", file=sys.stderr)
@@ -1780,8 +1966,12 @@ def main() -> int:
                              args.role, args.in_channel, since, until,
                              project=args.project, fmt=fmt,
                              exclude_current=args.exclude_current,
-                             current_uuid=current_uuid))
+                             current_uuid=current_uuid, full=args.full))
         return 0
+    if mode == "search":
+        # Reached only when no scope flag was given — search needs one of these.
+        print("search requires --file, --cwd, --project, or --all-projects", file=sys.stderr)
+        return 1
 
     # File-required modes
     if mode == "subagent-tools":
@@ -1874,13 +2064,6 @@ def main() -> int:
             if args.include_subagents:
                 body += _append_subagents(path)
             print(body)
-    elif mode == "search":
-        if not args.query:
-            print("--query required with --mode search", file=sys.stderr)
-            return 1
-        result = mode_search_legacy(lines, args.query)
-        print(result if result is not None
-              else f"No assistant messages containing '{args.query}' found.")
     elif mode == "debug":
         print(mode_debug(lines))
 

package/skills/estack-migrate-claude-session-history/scripts/test-append-note.js

@@ -1,48 +0,0 @@
-'use strict';
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-const mod = require('./migrate-claude-history.js');
-
-// Set up a tiny synthetic .jsonl in a temp dir
-const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'migrate-test-'));
-const testFile = path.join(tmp, 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee.jsonl');
-const sampleEntries = [
-  { type: 'permission-mode', permissionMode: 'default', sessionId: 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee' },
-  { type: 'user', message: { role: 'user', content: 'Hello' }, uuid: '11111111-1111-1111-1111-111111111111', parentUuid: null, sessionId: 'aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee', timestamp: '2026-05-24T18:00:00.000Z', cwd: 'C:\\fake\\old', version: '2.1.0' },
-];
-fs.writeFileSync(testFile, sampleEntries.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf8');
-
-const oldRepo = mod.parseWindowsRepoPath('C:\\fake\\old', 'old');
-const newRepo = mod.parseWindowsRepoPath('C:\\fake\\new', 'new');
-
-const summary = { migrationNotesAppended: 0, migrationNotesSkipped: 0 };
-
-// First call — should append
-mod.appendMigrationNote({ filePath: testFile, oldRepo, newRepo, dryRun: false, summary });
-console.log('After first call:', summary);
-
-// Second call — should detect duplicate and skip
-mod.appendMigrationNote({ filePath: testFile, oldRepo, newRepo, dryRun: false, summary });
-console.log('After second call:', summary);
-
-// Inspect the appended entry
-const lines = fs.readFileSync(testFile, 'utf8').split('\n').filter((l) => l.trim());
-const appended = JSON.parse(lines[lines.length - 1]);
-
-console.log('');
-console.log('=== Appended entry shape ===');
-console.log('type:    ', appended.type);
-console.log('isMeta:  ', 'isMeta' in appended ? appended.isMeta : '<not set>');
-console.log('parent:  ', appended.parentUuid);
-console.log('uuid:    ', appended.uuid);
-console.log('cwd:     ', appended.cwd);
-console.log('');
-console.log('=== content (first 200 chars) ===');
-console.log(appended.message.content.slice(0, 200) + '...');
-
-// Cleanup
-fs.rmSync(tmp, { recursive: true, force: true });
-console.log('');
-console.log('Test passed:', summary.migrationNotesAppended === 1 && summary.migrationNotesSkipped === 1 && !('isMeta' in appended) ? 'YES' : 'NO');