continuityguard-cli 0.1.0__py3-none-any.whl

continuityguard/__init__.py

@@ -0,0 +1,43 @@
+"""
+ContinuityGuard: a local, zero-network library and CLI that scores
+already-generated AI short-drama video clips for character-consistency
+drift and physics-plausibility issues.
+
+This is the Python port of the npm package `continuityguard-cli`
+(https://github.com/RudrenduPaul/ContinuityGuard). It is a genuine,
+independent port -- not a wrapper around the Node binary -- ported module
+for module from the TypeScript source (src/ingest/ffmpeg.ts,
+src/score/consistency.ts, src/score/physics.ts, src/report/*.ts,
+src/cli.ts) and using the exact same bundled ONNX model file
+(mobilenetv2-7.onnx) so both runtimes score the same input the same way.
+
+Public API:
+
+    from continuityguard import scan, ScanReport
+
+    report = scan("./generated-clips")
+    print(report.character_consistency.flagged_shots)
+"""
+from __future__ import annotations
+
+from .report.types import (
+    ConsistencyFlagReport,
+    PhysicsFlagReport,
+    CharacterConsistencyReport,
+    PhysicsPlausibilityReport,
+    ScanReport,
+)
+from .scan import scan, scan_async
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "scan",
+    "scan_async",
+    "ScanReport",
+    "ConsistencyFlagReport",
+    "PhysicsFlagReport",
+    "CharacterConsistencyReport",
+    "PhysicsPlausibilityReport",
+    "__version__",
+]

continuityguard/cli.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+CLI entry point. Wires the `scan` subcommand: CG01 ingestion -> CG02
+character-consistency scoring -> CG03 physics-plausibility heuristic ->
+CG04 report output (terminal by default, `--json` for machine-readable).
+
+Console entry point: `continuityguard scan <directory> [options]`,
+installed via the `continuityguard` console-script defined in
+python/pyproject.toml -- the same command name as the npm CLI's `bin`
+entry, so the two are drop-in equivalents on their respective toolchains.
+
+Zero-network guarantee: nothing in this file, or anything it imports from
+continuityguard.ingest or continuityguard.score, makes an outbound network
+call. The only I/O is local filesystem reads/writes and spawning the local
+`ffmpeg` binary via an explicit argument list (see ingest/ffmpeg.py).
+
+Ported from src/cli.ts, which uses `commander`; this port uses the stdlib
+`argparse` to avoid a CLI-framework dependency. Flags, defaults, and
+messages are kept as close to the npm CLI's `--help` output and error text
+as argparse's own conventions allow.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from .ingest.ffmpeg import build_missing_ffmpeg_message, check_ffmpeg_available
+from .report.json_report import serialize_report, write_json_report
+from .report.terminal import render_terminal_report
+from .scan import TOOL_VERSION, NoClipsFoundError, scan
+
+_PROG = "continuityguard"
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=_PROG,
+        description=(
+            "Free, local-first CLI that scores already-generated AI short-drama clips/frames "
+            "for character-consistency and physics-plausibility problems. Zero network calls."
+        ),
+    )
+    parser.add_argument(
+        "-V", "--version", action="version", version=f"{_PROG} {TOOL_VERSION}"
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    scan_parser = subparsers.add_parser(
+        "scan",
+        help=(
+            "scan a directory of generated clips for character-consistency and "
+            "physics-plausibility flags"
+        ),
+        description=(
+            "scan a directory of generated clips for character-consistency and "
+            "physics-plausibility flags"
+        ),
+    )
+    scan_parser.add_argument("directory", help="directory of video clips to scan")
+    scan_parser.add_argument(
+        "--json",
+        action="store_true",
+        default=False,
+        help="print the full machine-readable JSON report to stdout instead of a terminal summary",
+    )
+    scan_parser.add_argument(
+        "--fps",
+        type=float,
+        default=None,
+        help="frame sample rate for ingestion (default: 2.3)",
+    )
+    scan_parser.add_argument(
+        "--out",
+        default="./continuityguard-report.json",
+        help="path to write the JSON report file to",
+    )
+
+    return parser
+
+
+def run_scan(directory: str, json_output: bool = False, fps: Optional[float] = None, out: str = "./continuityguard-report.json") -> int:
+    """
+    Runs one scan end to end and returns the process exit code (0 success,
+    1 failure). Mirrors src/cli.ts's `runScan`: every failure path prints a
+    clean, actionable message to stderr and returns 1, rather than letting
+    a raw traceback / unhandled exception propagate.
+    """
+    ffmpeg_check = check_ffmpeg_available()
+    if not ffmpeg_check.available:
+        print(build_missing_ffmpeg_message(), file=sys.stderr)
+        return 1
+
+    target_dir = str(Path(directory).resolve())
+
+    try:
+        report = scan(directory, fps=fps)
+    except FileNotFoundError:
+        print(f"Directory not found: {target_dir}", file=sys.stderr)
+        return 1
+    except NotADirectoryError:
+        print(f"Not a directory: {target_dir}", file=sys.stderr)
+        return 1
+    except NoClipsFoundError as error:
+        # NoClipsFoundError's own message already carries the supported
+        # extensions list; split across two stderr lines to match the
+        # TS CLI's two separate console.error calls.
+        message = str(error)
+        head, _, tail = message.partition(". Supported extensions")
+        print(head + ".", file=sys.stderr)
+        if tail:
+            print("Supported extensions" + tail, file=sys.stderr)
+        return 1
+    except Exception as error:  # noqa: BLE001 -- top-level crash guard, mirrors src/cli.ts's catch-all
+        print(f"ContinuityGuard scan failed: {error}", file=sys.stderr)
+        return 1
+
+    if json_output:
+        sys.stdout.write(serialize_report(report))
+    else:
+        # Pass the raw --out value (not pre-resolved) so write_json_report's
+        # own traversal check runs against what the caller actually typed --
+        # resolving here first would turn every path absolute and silently
+        # bypass that check.
+        write_json_report(out, report)
+        out_path = str(Path(out).resolve())
+        print(render_terminal_report(report, out_path))
+
+    return 0
+
+
+def run_cli(argv: List[str]) -> int:
+    """`argv` follows the sys.argv convention: argv[0] is the program name,
+    real arguments start at argv[1]. Returns the process exit code."""
+    parser = build_parser()
+    args = parser.parse_args(argv[1:])
+
+    if args.command != "scan":
+        parser.print_help()
+        return 0
+
+    return run_scan(args.directory, json_output=args.json, fps=args.fps, out=args.out)
+
+
+def main() -> None:
+    sys.exit(run_cli(sys.argv))
+
+
+if __name__ == "__main__":
+    main()

continuityguard/ingest/__init__.py

@@ -0,0 +1 @@
+"""CG01 -- clip/frame ingestion. Ported from src/ingest/ffmpeg.ts."""

continuityguard/ingest/ffmpeg.py

@@ -0,0 +1,295 @@
+"""
+CG01 -- clip/frame ingestion.
+
+ContinuityGuard depends on a system `ffmpeg` install rather than bundling a
+static per-platform binary. A static ffmpeg build is materially larger than
+this package's own dependency footprint (commonly 50-80MB+ per platform
+depending on included codecs) and ffmpeg's licensing terms shift between
+LGPL and GPL depending on which codecs/filters are compiled in -- a real
+legal-review cost this project is not taking on. ffmpeg is a near-ubiquitous
+developer tool already (commonly pre-installed, or one `brew install
+ffmpeg` / `apt install ffmpeg` away), so this keeps the package small and
+its own licensing surface simple: ContinuityGuard's code never
+redistributes ffmpeg binaries or inherits their licensing obligations.
+
+Security note: every ffmpeg invocation in this module passes an explicit
+argument list to `subprocess` (never `shell=True`, never string
+concatenation into a shell command). Clip paths and directory paths --
+values that can originate from untrusted caller input -- are passed as
+individual argv elements, so shell metacharacters in a filename (spaces,
+`;`, `$()`, backticks, etc.) are never interpreted by a shell; they reach
+ffmpeg as literal argument bytes, exactly as Python's subprocess module
+guarantees for a list-form command with no shell.
+
+Ported from src/ingest/ffmpeg.ts.
+"""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+# Frame sample rate used for CG01 decode -- 2.3 fps, matching the plan's
+# "roughly 2-3 fps sample rate is fine" guidance for shot-level QA sampling.
+DEFAULT_SAMPLE_FPS = 2.3
+
+# Frames are decoded to headerless raw RGB24 at a fixed square size rather
+# than PNG. This is a deliberate simplification: it lets both scoring
+# modules (consistency.py, physics.py) read a frame as a fixed-length byte
+# buffer with zero image-decoding dependency, instead of pulling in a PNG
+# parser just to get back to raw pixels a moment later. The fixed 224x224
+# size also matches the embedding model's expected input dimensions (see
+# continuityguard/score/consistency.py), so one decode pass serves both
+# scoring paths.
+FRAME_SIZE = 224
+FRAME_BYTES = FRAME_SIZE * FRAME_SIZE * 3
+
+_SUPPORTED_CLIP_EXTENSIONS = {".mp4", ".mov", ".mkv", ".webm", ".avi"}
+
+# A crafted/malformed clip must never hang a scan indefinitely (this is the
+# only ffmpeg call in the whole codebase with no bound on wall-clock time --
+# check_ffmpeg_available's `-version` probe already has its own short timeout).
+_DEFAULT_FFMPEG_TIMEOUT_SECONDS = 120.0
+
+# Pre-flight cap before handing a file to ffmpeg at all: an oversized clip
+# can drive unbounded temp-disk usage (one frame_%04d.rgb per sampled
+# frame) and CPU time regardless of the decode timeout above.
+_MAX_CLIP_BYTES = 2 * 1024 * 1024 * 1024  # 2 GiB
+
+
+@dataclass(frozen=True)
+class FfmpegCheckResult:
+    available: bool
+    version: Optional[str] = None
+
+
+def check_ffmpeg_available() -> FfmpegCheckResult:
+    """Checks whether `ffmpeg` is reachable on PATH. Never raises -- callers
+    use the boolean result to decide whether to continue or print an
+    install command and exit."""
+    ffmpeg_path = shutil.which("ffmpeg")
+    if ffmpeg_path is None:
+        return FfmpegCheckResult(available=False)
+    try:
+        result = subprocess.run(
+            ["ffmpeg", "-version"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return FfmpegCheckResult(available=False)
+    if result.returncode != 0:
+        return FfmpegCheckResult(available=False)
+    first_line = result.stdout.split("\n", 1)[0] if result.stdout else ""
+    version = None
+    prefix = "ffmpeg version "
+    if first_line.startswith(prefix):
+        version = first_line[len(prefix) :].split(" ", 1)[0]
+    return FfmpegCheckResult(available=True, version=version)
+
+
+def detect_os(platform: Optional[str] = None) -> str:
+    import sys
+
+    plat = platform or sys.platform
+    if plat == "darwin":
+        return "macos"
+    if plat == "win32":
+        return "windows"
+    if plat.startswith("linux"):
+        if shutil.which("apt-get"):
+            return "debian"
+        if shutil.which("dnf") or shutil.which("yum"):
+            return "redhat"
+        return "debian"
+    return "unknown"
+
+
+def describe_ffmpeg_install_command(os_name: Optional[str] = None) -> str:
+    """Returns the exact, copy-pasteable install command for the detected OS."""
+    os_name = os_name or detect_os()
+    if os_name == "macos":
+        return "brew install ffmpeg"
+    if os_name == "debian":
+        return "sudo apt update && sudo apt install -y ffmpeg"
+    if os_name == "redhat":
+        return "sudo dnf install -y ffmpeg"
+    if os_name == "windows":
+        return "winget install ffmpeg (or: choco install ffmpeg)"
+    return "install ffmpeg via your OS package manager, or see https://ffmpeg.org/download.html"
+
+
+def build_missing_ffmpeg_message(os_name: Optional[str] = None) -> str:
+    return "\n".join(
+        [
+            "ContinuityGuard requires ffmpeg, and it was not found on PATH.",
+            f"Install it with:  {describe_ffmpeg_install_command(os_name)}",
+            "Then re-run your scan. ContinuityGuard never bundles ffmpeg itself --",
+            'see README "Requirements" for why.',
+        ]
+    )
+
+
+@dataclass(frozen=True)
+class ClipInfo:
+    path: str
+    name: str
+
+
+def list_clips(directory: str) -> List[ClipInfo]:
+    """Lists clip files (by extension) directly inside a directory, sorted
+    for deterministic scan ordering. Does not recurse into subdirectories."""
+    directory_path = Path(directory)
+    if not directory_path.exists():
+        raise FileNotFoundError(f"[Errno 2] No such file or directory: '{directory}'")
+    if not directory_path.is_dir():
+        raise NotADirectoryError(f"[Errno 20] Not a directory: '{directory}'")
+    entries = [
+        entry
+        for entry in directory_path.iterdir()
+        if entry.is_file() and entry.suffix.lower() in _SUPPORTED_CLIP_EXTENSIONS
+    ]
+    entries.sort(key=lambda entry: entry.name)
+    return [ClipInfo(path=str(entry), name=entry.name) for entry in entries]
+
+
+@dataclass
+class ExtractedFrames:
+    clip: ClipInfo
+    frame_dir: str
+    # Paths to headerless raw RGB24 frame files, FRAME_SIZE x FRAME_SIZE, in
+    # temporal order. Read with `read_raw_frame`.
+    frame_paths: List[str] = field(default_factory=list)
+
+
+def extract_frames(
+    clip: ClipInfo, fps: Optional[float] = None, work_dir: Optional[str] = None
+) -> ExtractedFrames:
+    """
+    Decodes a single clip into sampled raw RGB24 frames via ffmpeg, at
+    DEFAULT_SAMPLE_FPS unless overridden. Frames are written to a fresh
+    temp directory the caller is responsible for cleaning up (or use
+    `extract_frames_from_directory`, which cleans up automatically).
+
+    If ffmpeg fails (a corrupt file, an unsupported codec, a zero-byte
+    file, etc.) and this call created its own temp directory (no
+    `work_dir` override was passed in), that now-orphaned temp directory
+    is removed before the error is re-raised, rather than left behind on
+    disk.
+    """
+    fps = DEFAULT_SAMPLE_FPS if fps is None else fps
+    owns_frame_dir = work_dir is None
+    frame_dir = work_dir or tempfile.mkdtemp(prefix="continuityguard-frames-")
+
+    clip_size = Path(clip.path).stat().st_size
+    if clip_size > _MAX_CLIP_BYTES:
+        if owns_frame_dir:
+            shutil.rmtree(frame_dir, ignore_errors=True)
+        raise RuntimeError(
+            f'"{clip.name}" is {clip_size / (1024 * 1024):.0f}MB, over the '
+            f"{_MAX_CLIP_BYTES / (1024 * 1024 * 1024):.0f}GB per-clip limit -- skipped to "
+            "avoid unbounded temp-disk/CPU usage during decode"
+        )
+
+    try:
+        _run_ffmpeg(
+            [
+                "-y",
+                "-i",
+                clip.path,
+                "-vf",
+                f"fps={fps},scale={FRAME_SIZE}:{FRAME_SIZE}",
+                "-c:v",
+                "rawvideo",
+                "-pix_fmt",
+                "rgb24",
+                "-f",
+                "image2",
+                "-loglevel",
+                "error",
+                str(Path(frame_dir) / "frame_%04d.rgb"),
+            ]
+        )
+
+        frame_paths = sorted(
+            str(entry)
+            for entry in Path(frame_dir).iterdir()
+            if entry.name.startswith("frame_") and entry.name.endswith(".rgb")
+        )
+        return ExtractedFrames(clip=clip, frame_dir=frame_dir, frame_paths=frame_paths)
+    except Exception:
+        if owns_frame_dir:
+            shutil.rmtree(frame_dir, ignore_errors=True)
+        raise
+
+
+def extract_frames_from_directory(
+    directory: str, fps: Optional[float] = None
+) -> List[ExtractedFrames]:
+    """
+    Decodes every clip in a directory into sampled frames. Returns one
+    ExtractedFrames entry per clip. Callers should call `cleanup_frames`
+    when done to remove the temp directories.
+
+    If ffmpeg fails to decode any single clip (a corrupt file, an
+    unsupported codec, a zero-byte file, etc.), this raises a clear error
+    naming the offending clip, and first cleans up the temp frame
+    directories already created for clips that decoded successfully
+    earlier in the loop, so one bad clip in a batch never leaks temp
+    storage.
+    """
+    clips = list_clips(directory)
+    results: List[ExtractedFrames] = []
+    for clip in clips:
+        try:
+            results.append(extract_frames(clip, fps=fps))
+        except Exception as error:
+            cleanup_frames(results)
+            raise RuntimeError(f'Failed to decode "{clip.name}" with ffmpeg: {error}') from error
+    return results
+
+
+def read_raw_frame(frame_path: str) -> bytes:
+    """Reads a headerless raw RGB24 frame file back into a bytes object of
+    length FRAME_BYTES (FRAME_SIZE * FRAME_SIZE * 3, row-major, RGB)."""
+    data = Path(frame_path).read_bytes()
+    if len(data) != FRAME_BYTES:
+        raise ValueError(
+            f"Unexpected frame size for {frame_path}: got {len(data)} bytes, "
+            f"expected {FRAME_BYTES}"
+        )
+    return data
+
+
+def cleanup_frames(extracted: List[ExtractedFrames]) -> None:
+    for entry in extracted:
+        shutil.rmtree(entry.frame_dir, ignore_errors=True)
+
+
+def _run_ffmpeg(args: List[str]) -> None:
+    """Runs ffmpeg with an explicit argument list -- never a shell string --
+    so no filename or path, however untrusted, is ever interpreted as shell
+    syntax. Raises RuntimeError with ffmpeg's stderr on a non-zero exit, or
+    if the process exceeds the per-clip decode timeout (subprocess.run kills
+    and waits for the child automatically in that case)."""
+    try:
+        result = subprocess.run(
+            ["ffmpeg", *args],
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+            text=True,
+            timeout=_DEFAULT_FFMPEG_TIMEOUT_SECONDS,
+        )
+    except subprocess.TimeoutExpired as error:
+        raise RuntimeError(
+            f"ffmpeg did not finish within {_DEFAULT_FFMPEG_TIMEOUT_SECONDS:.0f}s "
+            "(likely a malformed/oversized input) and was killed"
+        ) from error
+    if result.returncode != 0:
+        stderr = (result.stderr or "").strip()
+        raise RuntimeError(f"ffmpeg exited with code {result.returncode}: {stderr}")

continuityguard/report/__init__.py

@@ -0,0 +1,4 @@
+"""CG04 -- report output. Shared report shape (types.py) consumed by both
+the JSON writer (json_report.py) and the terminal writer (terminal.py).
+Ported from src/report/*.ts.
+"""

continuityguard/report/json_report.py

@@ -0,0 +1,52 @@
+"""
+CG04 -- machine-readable JSON report output (`--json` mode). Built so a
+QA agent or CI pipeline can parse scan results programmatically, with the
+same "no bare pass/fail" guarantee as the terminal report: every flagged
+shot carries a reason string alongside its numeric score.
+
+Ported from src/report/json.ts. Named json_report.py (not json.py) so it
+never shadows the stdlib `json` module it imports.
+"""
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import asdict
+from pathlib import Path
+from typing import Union
+
+from .types import ScanReport
+
+
+class UnsafeOutputPathError(ValueError):
+    pass
+
+
+# --out is a plain CLI flag today, but this CLI is also meant to be invoked
+# programmatically by agents that may derive the value from less-trusted
+# input. A relative path containing ".." segments can escape the intended
+# output location entirely (--out ../../../etc/cron.d/x) -- reject any
+# --out value that resolves outside the current working directory. An
+# explicit absolute path is still allowed: that's a value the caller
+# typed/passed directly, not one that silently escaped via traversal.
+def _assert_safe_output_path(file_path: Union[str, Path]) -> None:
+    file_path = str(file_path)
+    if os.path.isabs(file_path):
+        return
+    cwd = os.path.realpath(os.getcwd())
+    resolved = os.path.realpath(os.path.join(cwd, file_path))
+    if resolved != cwd and not resolved.startswith(cwd + os.sep):
+        raise UnsafeOutputPathError(
+            f'--out "{file_path}" resolves outside the current working directory '
+            f"({resolved}). Pass an absolute path if you intend to write outside "
+            "the working directory."
+        )
+
+
+def serialize_report(report: ScanReport) -> str:
+    return json.dumps(asdict(report), indent=2) + "\n"
+
+
+def write_json_report(path: Union[str, Path], report: ScanReport) -> None:
+    _assert_safe_output_path(path)
+    Path(path).write_text(serialize_report(report), encoding="utf-8")

continuityguard/report/terminal.py

@@ -0,0 +1,85 @@
+"""
+CG04 -- human-readable terminal report output. Every flagged shot
+includes a timestamp/frame reference, a numeric score, and a
+plain-language reason -- built for a human studio QA reviewer to read
+directly.
+
+Ported line-for-line from src/report/terminal.ts so the two CLIs print
+matching output.
+"""
+from __future__ import annotations
+
+from typing import List, Optional
+
+from .types import ScanReport
+
+
+def render_terminal_report(report: ScanReport, json_path: Optional[str] = None) -> str:
+    lines: List[str] = []
+    lines.append("ContinuityGuard v0.1 -- Local Character-Consistency & Physics-QA Scoring")
+    lines.append("")
+    lines.append(
+        f"Scanning: {report.scanned_directory} ({report.clips_scanned} clips, ffmpeg decode)"
+    )
+    lines.append("")
+
+    lines.append("[SCORED] CG01 Clip Ingestion")
+    lines.append(
+        f"  {report.clips_scanned} clips decoded, {report.frames_extracted} frames extracted"
+    )
+    lines.append("")
+
+    lines.append("[SCORED] CG02 Character-Consistency Scoring")
+    lines.append(
+        f"  {report.character_consistency.characters_tracked} named characters tracked "
+        f"across {report.clips_scanned} clips"
+    )
+    consistency_flags = report.character_consistency.flagged_shots
+    if not consistency_flags:
+        lines.append(
+            f"  0 shots flagged (below "
+            f"{report.character_consistency.similarity_threshold:.2f} cosine threshold)"
+        )
+    else:
+        lines.append(
+            f"  {len(consistency_flags)} shot(s) flagged: low cross-shot similarity "
+            f"(below {report.character_consistency.similarity_threshold:.2f} cosine threshold)"
+        )
+        for flag in consistency_flags:
+            lines.append(
+                f'    {flag.clip} -- "{flag.character}" similarity '
+                f"{flag.similarity_score:.2f} vs. reference ({flag.reference_clip})"
+            )
+    lines.append("  NOTE: consistency scoring is best-validated on photorealistic content.")
+    lines.append("  Accuracy on stylized/anime-adjacent character designs is unverified --")
+    lines.append("  treat flags on stylized content as a prompt for human review, not a")
+    lines.append('  confirmed defect. See README "Known limitations."')
+    lines.append("")
+
+    lines.append("[SCORED] CG03 Physics-Plausibility Heuristic")
+    physics_flags = report.physics_plausibility.flagged_shots
+    if not physics_flags:
+        lines.append("  0 shots flagged: no frame-to-frame motion discontinuity above threshold")
+    else:
+        lines.append(
+            f"  {len(physics_flags)} shot(s) flagged: frame-to-frame motion discontinuity "
+            f"above threshold"
+        )
+        for flag in physics_flags:
+            lines.append(
+                f"    {flag.clip} @ frame {flag.frame_index_a}-{flag.frame_index_b} -- "
+                f"discontinuity {flag.discontinuity_ratio}x local baseline"
+            )
+    lines.append("  This is a heuristic proxy, not a physics simulator. It flags shots for")
+    lines.append('  human review. It does not "detect" a physics violation.')
+    lines.append("")
+
+    if json_path:
+        lines.append(f"Report written to {json_path}")
+    lines.append("Human-readable summary above. Use --json for the full structured report.")
+    lines.append(
+        f"Scan time: {report.scan_duration_seconds:.1f}s. Nothing left this machine. "
+        f"No network calls were made."
+    )
+
+    return "\n".join(lines)