roar-cli 0.3.5__tar.gz → 0.3.6__tar.gz

{roar_cli-0.3.5 → roar_cli-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: roar-cli
-Version: 0.3.5
+Version: 0.3.6
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research

{roar_cli-0.3.5 → roar_cli-0.3.6}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 
 [project]
 name = "roar-cli"
-version = "0.3.5"
+version = "0.3.6"
 description = "Reproducibility and provenance tracker for ML training pipelines"
 authors = [
     { name="TReqs Team", email="info@treqs.ai" }

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/git.py

@@ -3,12 +3,13 @@
 from __future__ import annotations
 
 import subprocess
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
 
 from ..core.interfaces.logger import ILogger
 from ..core.interfaces.registration import GitContext
 from ..integrations.git import GitVCSProvider, resolve_git_context
+from ..utils.git_url import is_shareable_remote
 
 
 @dataclass(frozen=True)
@@ -68,6 +69,17 @@ def resolve_roar_git_context(
     """
     logger.debug("Resolving git context from %s", path)
     ctx = resolve_git_context(path, git_commit, configured_remote=configured_remote)
+    # A repo with no real remote records its own ``file://`` path as the URL.
+    # That resolves only on this machine, so publishing it both leaks the
+    # user's local filesystem layout to GLaaS and is useless to anyone else.
+    # This resolver is publish-only (register/put/package prep), so drop the
+    # non-shareable URL here — the publish record then honestly shows "no
+    # remote", matching the reproducibility checklist. (Local recording uses
+    # ``resolve_git_context`` directly and keeps the ``file://`` URI, which
+    # in-place reproduce relies on.)
+    if ctx.repo and not is_shareable_remote(ctx.repo):
+        logger.debug("Dropping non-shareable git repo URL from publish context: %s", ctx.repo)
+        ctx = replace(ctx, repo=None)
     logger.debug(
         "Git context resolved: repo=%s, commit=%s, branch=%s",
         ctx.repo,

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/publish/git_remote.py

@@ -60,7 +60,8 @@ def _git_check_output(repo_root: Path | str, *args: str, capture_stderr: bool) -
     )
 
 
-def _list_remote_names(repo_root: Path | str) -> list[str]:
+def list_remote_names(repo_root: Path | str) -> list[str]:
+    """Return the names of git remotes configured in this repo (empty if none)."""
     try:
         raw = _git_check_output(repo_root, "remote", capture_stderr=False)
     except subprocess.CalledProcessError:
@@ -68,6 +69,10 @@ def _list_remote_names(repo_root: Path | str) -> list[str]:
     return [line.strip() for line in raw.splitlines() if line.strip()]
 
 
+# Back-compat alias for internal callers.
+_list_remote_names = list_remote_names
+
+
 def resolve_canonical_remote(repo_root: Path | str, configured_remote: str | None) -> str:
     """Return the name of the remote roar should push tags to.
 

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/publish/register_execution.py

@@ -469,8 +469,18 @@ class RegisterService:
 
         composite_registered = sum(1 for item in composite_registrations if item.get("registered"))
         composite_failed = sum(1 for item in composite_registrations if not item.get("registered"))
-        total_artifacts_registered = batch_result.artifacts_registered + composite_registered
         total_artifacts_failed = batch_result.artifacts_failed + composite_failed
+        # Report DISTINCT artifacts, matching `register --dry-run`'s
+        # len(lineage.artifacts). The coordinator's running tally double-counts
+        # (artifacts are tallied in both the staging and the link phase, and the
+        # server's success count is per content-hash) — when everything
+        # registered, the distinct figure is simply the lineage's artifact count.
+        # The success gate below keys off *_failed, not this display number, so
+        # this is safe. On partial failure, fall back to the coordinator's tally.
+        if total_artifacts_failed == 0:
+            total_artifacts_registered = len(lineage.artifacts)
+        else:
+            total_artifacts_registered = batch_result.artifacts_registered + composite_registered
 
         success = (
             batch_result.jobs_failed == 0 and total_artifacts_failed == 0 and not finalize_failed

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/publish/register_tag_push.py

@@ -33,6 +33,7 @@ from ...core.interfaces.logger import ILogger
 from ..git import build_roar_git_tag_name, create_roar_git_tag
 from .git_remote import (
     GitRemoteError,
+    list_remote_names,
     push_roar_tags,
     resolve_canonical_remote,
     warn_if_ssh_passphrase_prompt_likely,
@@ -145,6 +146,21 @@ def ensure_roar_tags_pushed(
             push_skipped_reason="never_config",
         )
 
+    # No remote at all (and none configured): degrade to a local-only register
+    # instead of blocking. The common "does this work" loop shouldn't be gated on
+    # having a remote — and the dry-run never blocks, so the real run shouldn't
+    # contradict it. Tags exist locally; the reproducibility checklist surfaces
+    # that the commit isn't reachable on a remote. (An *invalid* configured
+    # remote or ambiguous multi-remote setup still errors below — those mean the
+    # user wants a push but roar can't safely pick where.)
+    if not configured_remote and not list_remote_names(repo_root):
+        logger.debug("No git remote configured — registering local-only (tags not pushed).")
+        return RegisterTagSummary(
+            session_tag=session_tag_name,
+            job_tags=job_tags,
+            push_skipped_reason="no_remote",
+        )
+
     try:
         remote = resolve_canonical_remote(repo_root, configured_remote)
     except GitRemoteError as exc:

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/publish/registration_package.py

@@ -134,6 +134,9 @@ def build_registration_package(
         git_context=git_context,
         cwd=cwd,
     )
+    redacted_lineage, redacted_git_context = _drop_local_remotes(
+        redacted_lineage, redacted_git_context
+    )
 
     registration_jobs = order_jobs_for_registration(
         normalize_jobs_for_registration(redacted_lineage.jobs)
@@ -263,6 +266,27 @@ def _apply_redaction(
     )
 
 
+def _drop_local_remotes(
+    lineage: LineageData, git_context: GitContext
+) -> tuple[LineageData, GitContext]:
+    """Don't publish non-shareable (``file://`` / local-path) git repos to GLaaS.
+
+    A repo with no real remote records its own ``file://`` path as ``git_repo``;
+    publishing that leaks the local filesystem path and is useless to anyone else.
+    Replace such repos with "" so the GLaaS record honestly shows no remote — the
+    reproducibility checklist already flags this as "commit reachable on a remote".
+    """
+    from ...utils.git_url import is_shareable_remote
+
+    if git_context.repo and not is_shareable_remote(git_context.repo):
+        git_context = GitContext(repo="", commit=git_context.commit, branch=git_context.branch)
+    for job in lineage.jobs:
+        repo = job.get("git_repo")
+        if isinstance(repo, str) and repo and not is_shareable_remote(repo):
+            job["git_repo"] = ""
+    return lineage, git_context
+
+
 def _filter_git_context(
     git_context: GitContext,
     omit_filter: OmitFilter | None,

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/publish/results.py

@@ -49,6 +49,11 @@ class RegisterLineageResponse:
     # the CLI surfaces a notice so the user knows it can't be reproduced from
     # source. Defaults True so existing/normal registrations are unaffected.
     reproducible: bool = True
+    # False when the session's steps span more than one git commit (the user
+    # committed between runs). Computed from the session's commit span — the
+    # SAME source `roar reproduce` uses — so the two checklists never disagree.
+    # Defaults True so single-commit/normal registrations are unaffected.
+    single_commit: bool = True
 
 
 @dataclass(frozen=True)
@@ -94,3 +99,8 @@ class PutResponse:
     git_tag: str | None = None
     warnings: list[str] = field(default_factory=list)
     error: str | None = None
+    # Reproducibility-checklist inputs, mirroring RegisterLineageResponse so
+    # `roar put` can render the same receipt as `roar register`.
+    reproducible: bool = True  # the published run has a git commit
+    single_commit: bool = True  # the session's steps share one commit
+    commit_on_remote: bool = False  # the commit is reachable on a shareable remote

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/publish/service.py

@@ -370,13 +370,13 @@ def _resolve_register_preview_git_context(*, path: Path, logger: Any) -> Any:
     commit = _run_git(repo_root_path, "rev-parse", "HEAD")
     branch = _run_git(repo_root_path, "rev-parse", "--abbrev-ref", "HEAD")
     remote = _run_git(repo_root_path, "remote", "get-url", "origin")
-    repo = remote or repo_root_path.resolve().as_uri()
+    # Publish-only preview: never record a local ``file://`` URI here. A repo
+    # with no shareable remote publishes as "no remote" (matching the real
+    # register path, which drops it in `resolve_roar_git_context`) rather than
+    # leaking the local filesystem path to GLaaS.
+    repo = remote if remote else None
     if remote is None:
-        logger.debug(
-            "No git remote configured for %s; using local repository URI %s",
-            repo_root_path,
-            repo,
-        )
+        logger.debug("No git remote configured for %s; publishing with no remote", repo_root_path)
 
     return GitContext(repo=repo, commit=commit, branch=branch)
 
@@ -436,6 +436,31 @@ def _form_lineage_composites_for_lineage(*, roar_dir: Path, lineage: Any, logger
         return form_lineage_composites(db_ctx=form_db, job_ids=job_ids, logger=logger)
 
 
+def _session_single_commit(*, roar_dir: Path, session_id: Any) -> bool:
+    """True iff the session's steps all ran at one git commit.
+
+    Computed from the session's commit span (``git_commit_start`` vs
+    ``git_commit_end``) — the SAME formula ``roar reproduce`` uses (see
+    ``reproduce/lookup.py``) — so register's receipt and reproduce's preview can
+    never disagree on the "single git commit" check. The old proxy (extra job
+    tags) read False-positive whenever tagging was skipped (e.g. no remote),
+    silently mis-scoring multi-commit lineages as single-commit. Best-effort:
+    defaults True (the existing assume-single behavior) on any miss.
+    """
+    if session_id is None:
+        return True
+    try:
+        with create_query_database_context(roar_dir) as db_ctx:
+            session = db_ctx.sessions.get(session_id)
+    except Exception:
+        return True
+    if not session:
+        return True
+    start = session.get("git_commit_start")
+    end = session.get("git_commit_end")
+    return not (start and end and start != end)
+
+
 def _load_remote_job_uid_mapping(*, roar_dir: Path, session_id: Any) -> dict[str, str]:
     """Return the ``{local_job_uid: remote_job_uid}`` map registration persisted.
 
@@ -593,6 +618,12 @@ def register_lineage_target(request: RegisterLineageRequest) -> RegisterLineageR
             except Exception as exc:  # attribution is best-effort
                 logger.debug("anchor attribution skipped: %s", exc)
 
+        # Did the lineage span more than one git commit? Compute it the same way
+        # `roar reproduce` does (commit span), so the two checklists agree.
+        single_commit = _session_single_commit(
+            roar_dir=request.roar_dir, session_id=collected_lineage.session_id
+        )
+
         # Collapse each job's dataset membership into consumes/produces view edges (a
         # bloom over the touched leaves) and prune the subsumed leaves from the bundle.
         # Pushed after the main registration. Best-effort.
@@ -637,7 +668,9 @@ def register_lineage_target(request: RegisterLineageRequest) -> RegisterLineageR
             )
 
         if request.dry_run:
-            return preview_register_lineage(
+            from dataclasses import replace
+
+            preview = preview_register_lineage(
                 lineage=collected_lineage.lineage,
                 artifact_hash=collected_lineage.artifact_hash,
                 prepared=prepared,
@@ -645,6 +678,7 @@ def register_lineage_target(request: RegisterLineageRequest) -> RegisterLineageR
                 skip_confirmation=request.skip_confirmation,
                 confirm_callback=request.confirm_callback,
             )
+            return replace(preview, single_commit=single_commit)
 
         # P1-23: push roar tags BEFORE writing the GLaaS record so the
         # record never references a tag that doesn't yet exist on the
@@ -743,33 +777,27 @@ def register_lineage_target(request: RegisterLineageRequest) -> RegisterLineageR
             tag_summary=tag_summary,
             warnings=warnings,
             reproducible=bool(prepared.git_context.commit),
+            single_commit=single_commit,
         )
     except PublishAuthError as exc:
         return RegisterLineageResponse(success=False, error=str(exc))
 
 
 def _format_anonymous_tag_push_warning(tag_push_error: str) -> str:
-    """Wrap a tag-push failure as a self-contained user-facing warning.
-
-    Anonymous register continues past the push failure (GLaaS publish
-    succeeds), so the message has to (a) make clear the failure is git
-    remote auth, not GLaaS, (b) tell the user GLaaS registration still
-    happened, (c) explain why the missing push matters (the GLaaS
-    record references a tag that doesn't yet exist on the remote, so
-    anyone reading the record can't ``git checkout`` it), and
-    (d) point at the real fix (configure git remote auth + push the
-    tag). We deliberately do *not* suggest
-    ``git.push_tags_on_register=never`` here — that "fix" breaks
-    reproducibility for everyone viewing the GLaaS record, not just
-    silences a local warning.
+    """One-line tag-push-failure warning for the anonymous register path.
+
+    Anonymous register continues past a push failure (GLaaS publish succeeds).
+    The "why a missing push matters" explanation now lives in the reproducibility
+    checklist's ``commit reachable on a remote`` item, so this stays terse: name
+    that the failure is git-remote auth (not GLaaS), that the record was still
+    registered, the fix, and the verbatim git error. (Deliberately not suggesting
+    ``git.push_tags_on_register=never`` — that "fix" breaks reproducibility for
+    everyone reading the record, it doesn't just silence the warning.)
     """
     return (
-        "roar tag push to git remote failed (git auth, not GLaaS) — "
-        "anonymous register continued without pushing the tag.\n"
-        "  The local tag exists, but viewers of the GLaaS record need it "
-        "on the remote to reproduce.\n"
-        "  Fix git remote auth, then push: `git push <remote> <tag>`.\n"
-        f"  Verbatim git error: {tag_push_error}"
+        "roar tag push to the git remote failed (git auth, not GLaaS) — registered "
+        "without it; the 'commit reachable on a remote' check flags this. "
+        f"Fix git remote auth and re-push (`git push <remote> <tag>`). git: {tag_push_error}"
     )
 
 
@@ -787,6 +815,9 @@ def put_artifacts(request: PutRequest) -> PutResponse:
         )
 
     repo_root = request.repo_root or request.cwd
+    # Reproducibility-checklist facts, filled in on the real (non-dry-run) path.
+    put_single_commit = True
+    put_commit_on_remote = False
     if request.dry_run:
         git_state = None
         git_commit = None
@@ -842,6 +873,17 @@ def put_artifacts(request: PutRequest) -> PutResponse:
                 logger=logger,
             )
 
+            # Reproducibility facts for the receipt: same commit-span source as
+            # register/reproduce, and whether the commit is reachable on a real
+            # remote (git_context.repo is None here when no shareable remote —
+            # resolve_roar_git_context drops local file:// URIs).
+            from ...utils.git_url import is_shareable_remote
+
+            put_single_commit = _session_single_commit(
+                roar_dir=request.roar_dir, session_id=prepared.session_id
+            )
+            put_commit_on_remote = is_shareable_remote(prepared.git_context.repo)
+
             result = service.put_prepared(
                 prepared=prepared,
                 sources=request.sources,
@@ -886,6 +928,9 @@ def put_artifacts(request: PutRequest) -> PutResponse:
         git_tag=created_git_tag,
         warnings=warnings,
         error=result.error,
+        reproducible=bool(git_commit),
+        single_commit=put_single_commit,
+        commit_on_remote=put_commit_on_remote,
     )
 
 

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/query/inputs.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import os
+import subprocess
 from pathlib import Path
 from typing import Any
 
@@ -29,16 +30,45 @@ def render_inputs(request: InputsQueryRequest) -> str:
         return summary.message
 
     lines: list[str] = []
+    any_unsourced = any(a.unsourced for a in summary.artifacts)
+    tmp_unsourced = sum(
+        1 for a in summary.artifacts if a.unsourced and is_ephemeral_tmp_path(a.path)
+    )
     for art in summary.artifacts:
         digest = _short_digest(art.hashes)
         path = art.path or "(no path)"
-        if digest:
-            lines.append(f"{path}  {digest}")
-        else:
-            lines.append(path)
+        marker = "⚠ " if art.unsourced else ("  " if any_unsourced else "")
+        suffix = f"  {digest}" if digest else ""
+        lines.append(f"{marker}{path}{suffix}")
+    if any_unsourced:
+        lines.append("")
+        lines.append(
+            "⚠ unsourced: nothing tracked produced this file, so it won't exist on another machine."
+        )
+        lines.append(
+            "  Make it reproducible — commit code to a git repo, or ingest data with "
+            "`roar get <url>` / `roar run wget <url>`."
+        )
+        if tmp_unsourced:
+            lines.append(
+                f"⚠ {tmp_unsourced} in /tmp — these definitely won't survive; "
+                "move into your project or ingest with `roar get`."
+            )
     return "\n".join(lines)
 
 
+def is_ephemeral_tmp_path(path: str | None) -> bool:
+    """True for an input under an ephemeral tmp dir (Linux /tmp, macOS var/folders).
+
+    Such a file is guaranteed not to exist when the lineage is reproduced on
+    another machine — a sharper, more certain failure than generic
+    unsourcedness, so it warrants its own escalated warning.
+    """
+    if not path:
+        return False
+    return path.startswith("/tmp/") or "/private/var/folders/" in path
+
+
 def _short_digest(hashes: list[ShowHashSummary]) -> str:
     """Return a short display digest like 'blake3:abcdef01...'."""
     for h in hashes:
@@ -67,14 +97,20 @@ def build_inputs_summary(request: InputsQueryRequest) -> InputsSummary:
                 message=f'"{target_label}" is a root artifact (no upstream inputs)',
             )
 
+        git_tracked = _git_tracked_paths(request.cwd)
         if request.direct:
-            artifacts = _get_direct_inputs(db_ctx, target_artifact_ids)
+            artifacts = _get_direct_inputs(db_ctx, target_artifact_ids, git_tracked)
         elif request.show_all:
             artifacts = _walk_upstream_all(
-                db_ctx, target_artifact_ids, exclude=set(target_artifact_ids)
+                db_ctx, target_artifact_ids, git_tracked, exclude=set(target_artifact_ids)
             )
         else:
-            artifacts = _walk_upstream_roots(db_ctx, target_artifact_ids)
+            artifacts = _walk_upstream_roots(db_ctx, target_artifact_ids, git_tracked)
+
+        if request.unsourced:
+            artifacts = [a for a in artifacts if a.unsourced]
+        elif request.sourced:
+            artifacts = [a for a in artifacts if not a.unsourced]
 
         return InputsSummary(
             target_ref=target_label,
@@ -201,7 +237,56 @@ def _is_root_artifact(db_ctx, artifact_id: str) -> bool:
     return len(inputs) == 0
 
 
-def _make_artifact_summary(artifact: dict[str, Any]) -> InputArtifactSummary:
+def _git_tracked_paths(cwd: Path) -> frozenset[str]:
+    """Absolute paths of every file git tracks in ``cwd``'s repo (empty if none).
+
+    Used to recognise inputs that are *sourced by git*: a producer-less file that
+    git tracks is restored by ``roar reproduce`` (it checks out the commit), so
+    it is NOT unsourced even though nothing in the lineage produced it.
+    """
+    try:
+        root = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=str(cwd),
+            capture_output=True,
+            text=True,
+            check=False,
+        ).stdout.strip()
+        if not root:
+            return frozenset()
+        out = subprocess.run(
+            ["git", "ls-files", "-z"], cwd=root, capture_output=True, text=True, check=False
+        )
+    except OSError:
+        return frozenset()
+    return frozenset(os.path.join(root, p) for p in out.stdout.split("\0") if p)
+
+
+def _sourced_by_git(artifact: dict[str, Any] | None, git_tracked: frozenset[str]) -> bool:
+    """True iff a producer-less artifact is still recoverable because git tracks it."""
+    path = (artifact or {}).get("first_seen_path") or ""
+    return bool(path) and os.path.abspath(path) in git_tracked
+
+
+def _is_unsourced(db_ctx, artifact_id: str, git_tracked: frozenset[str]) -> bool:
+    """True iff this artifact won't exist on another machine.
+
+    Distinct from ``_is_root_artifact``: a producer-with-no-inputs (e.g. a
+    ``roar get`` source node, a ``roar run wget`` download, or a deterministic
+    generator) is a root but IS sourced — it re-runs on reproduce. An artifact
+    with no producer is sourced only if git tracks it (``roar reproduce`` checks
+    out the commit and restores it); otherwise it's truly unsourced (a
+    pre-existing, un-ingested, uncommitted file).
+    """
+    produced_by = db_ctx.artifacts.get_jobs(artifact_id).get("produced_by", [])
+    if produced_by:
+        return False
+    return not _sourced_by_git(db_ctx.artifacts.get(artifact_id), git_tracked)
+
+
+def _make_artifact_summary(
+    artifact: dict[str, Any], *, unsourced: bool = False
+) -> InputArtifactSummary:
     """Build an InputArtifactSummary from a raw artifact dict."""
     return InputArtifactSummary(
         artifact_id=str(artifact["id"]),
@@ -214,10 +299,13 @@ def _make_artifact_summary(artifact: dict[str, Any]) -> InputArtifactSummary:
             )
             for h in artifact.get("hashes", [])
         ],
+        unsourced=unsourced,
     )
 
 
-def _walk_upstream_roots(db_ctx, start_artifact_ids: list[str]) -> list[InputArtifactSummary]:
+def _walk_upstream_roots(
+    db_ctx, start_artifact_ids: list[str], git_tracked: frozenset[str]
+) -> list[InputArtifactSummary]:
     """Walk the DAG upstream and collect only root artifacts (no producer)."""
     roots: dict[str, InputArtifactSummary] = {}
     visited: set[str] = set()
@@ -235,18 +323,22 @@ def _walk_upstream_roots(db_ctx, start_artifact_ids: list[str]) -> list[InputArt
         produced_by = jobs.get("produced_by", [])
 
         if not produced_by:
-            # No producer at all — this is a root
+            # No producer — unsourced unless git tracks it (reproduce restores
+            # a committed file from the recorded commit).
             artifact = db_ctx.artifacts.get(artifact_id)
             if artifact:
-                roots[artifact_id] = _make_artifact_summary(artifact)
+                roots[artifact_id] = _make_artifact_summary(
+                    artifact, unsourced=not _sourced_by_git(artifact, git_tracked)
+                )
         else:
             producer = produced_by[0]
             inputs = db_ctx.jobs.get_inputs(producer["id"])
             if not inputs:
-                # Producer has no inputs (e.g., roar get) — treat this artifact as a root
+                # Producer has no inputs (e.g., roar get / wget / a generator) —
+                # a root, but SOURCED: it re-runs on reproduce.
                 artifact = db_ctx.artifacts.get(artifact_id)
                 if artifact:
-                    roots[artifact_id] = _make_artifact_summary(artifact)
+                    roots[artifact_id] = _make_artifact_summary(artifact, unsourced=False)
             else:
                 for inp in inputs:
                     _trace(inp["artifact_id"])
@@ -259,7 +351,9 @@ def _walk_upstream_roots(db_ctx, start_artifact_ids: list[str]) -> list[InputArt
     return list(roots.values())
 
 
-def _get_direct_inputs(db_ctx, start_artifact_ids: list[str]) -> list[InputArtifactSummary]:
+def _get_direct_inputs(
+    db_ctx, start_artifact_ids: list[str], git_tracked: frozenset[str]
+) -> list[InputArtifactSummary]:
     """Get only the immediate inputs (one level up)."""
     seen: dict[str, InputArtifactSummary] = {}
 
@@ -274,13 +368,19 @@ def _get_direct_inputs(db_ctx, start_artifact_ids: list[str]) -> list[InputArtif
                 if aid not in seen:
                     artifact = db_ctx.artifacts.get(aid)
                     if artifact:
-                        seen[aid] = _make_artifact_summary(artifact)
+                        seen[aid] = _make_artifact_summary(
+                            artifact, unsourced=_is_unsourced(db_ctx, aid, git_tracked)
+                        )
 
     return list(seen.values())
 
 
 def _walk_upstream_all(
-    db_ctx, start_artifact_ids: list[str], *, exclude: set[str] | None = None
+    db_ctx,
+    start_artifact_ids: list[str],
+    git_tracked: frozenset[str],
+    *,
+    exclude: set[str] | None = None,
 ) -> list[InputArtifactSummary]:
     """Walk the DAG upstream and collect all artifacts (intermediates + roots)."""
     exclude = exclude or set()
@@ -296,13 +396,16 @@ def _walk_upstream_all(
         visited.add(artifact_id)
         path_stack.add(artifact_id)
 
+        # Fetch producers once; reuse for both the unsourced flag and traversal.
+        jobs = db_ctx.artifacts.get_jobs(artifact_id)
+        produced_by = jobs.get("produced_by", [])
+
         if artifact_id not in exclude:
             artifact = db_ctx.artifacts.get(artifact_id)
             if artifact:
-                collected[artifact_id] = _make_artifact_summary(artifact)
+                unsourced = not produced_by and not _sourced_by_git(artifact, git_tracked)
+                collected[artifact_id] = _make_artifact_summary(artifact, unsourced=unsourced)
 
-        jobs = db_ctx.artifacts.get_jobs(artifact_id)
-        produced_by = jobs.get("produced_by", [])
         if produced_by:
             producer = produced_by[0]
             inputs = db_ctx.jobs.get_inputs(producer["id"])

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/query/requests.py

@@ -136,3 +136,5 @@ class InputsQueryRequest:
     direct: bool = False
     show_all: bool = False
     output_json: bool = False
+    unsourced: bool = False  # show only unsourced inputs (no producer)
+    sourced: bool = False  # show only sourced inputs (produced/ingested by roar)

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/query/results.py

@@ -343,6 +343,10 @@ class InputArtifactSummary:
     path: str
     size: int
     hashes: list[ShowHashSummary] = field(default_factory=list)
+    # True when nothing tracked produced this artifact (no producing job and not
+    # ingested via `roar get` / `roar run wget`). Such inputs won't exist on
+    # another machine, so the lineage that consumes them isn't reproducible.
+    unsourced: bool = False
 
 
 @dataclass(frozen=True)

{roar_cli-0.3.5 → roar_cli-0.3.6}/roar/application/query/status.py

@@ -116,6 +116,59 @@ def render_status(request: StatusQueryRequest) -> str:
     return "\n".join(lines)
 
 
+def session_output_paths(roar_dir) -> list[str]:
+    """Filesystem paths of the active session's distinct output artifacts.
+
+    A lightweight counterpart to ``build_status_summary``: no publish-auth
+    resolution and no canonical dag-hash — just the paths. Callers like the
+    artifact-path reproducibility check need only the paths, and must not trigger
+    auth side effects (resolving SSH/creator identity would, e.g., inject a
+    signed request into an otherwise-anonymous publish).
+    """
+    with create_query_database_context(roar_dir) as db_ctx:
+        session = db_ctx.sessions.get_active()
+        if not session:
+            return []
+        distinct_outputs = getattr(db_ctx.jobs, "get_distinct_outputs_by_session", None)
+        if callable(distinct_outputs):
+            outputs = distinct_outputs(session["id"])
+        else:
+            seen: set[int | str] = set()
+            outputs = []
+            for job in db_ctx.jobs.get_by_session(session["id"], limit=10000):
+                for output in db_ctx.jobs.get_outputs(job["id"]):
+                    if output["artifact_id"] not in seen:
+                        seen.add(output["artifact_id"])
+                        outputs.append(output)
+        return [str(output["path"]) for output in outputs if output["path"]]
+
+
+def render_untracked_dirs(request: StatusQueryRequest, cwd) -> str:
+    """Focused view: the session's output artifacts whose directory won't exist
+    on a clean checkout (untracked in-repo dirs, or paths outside the repo).
+
+    Backs the `all artifact paths in tracked directories` reproducibility check;
+    surfaced as `roar status --untracked-dirs` so the user can see exactly which
+    paths the check is flagging."""
+    from ..reproducibility.report import untracked_artifact_dirs
+
+    paths = untracked_artifact_dirs(request.roar_dir, cwd)
+    if paths is None:
+        return "Not in a git repository — artifact-path tracking doesn't apply."
+    if not paths:
+        return "All artifact paths are in tracked directories."
+
+    lines = [f"Artifacts in untracked directories ({len(paths)}):"]
+    lines.extend(f"  {path}" for path in paths)
+    lines.append("")
+    lines.append(
+        "These directories won't exist on a clean checkout, so reproduction may "
+        "fail unless the run recreates them."
+    )
+    lines.append("Add a .gitkeep (or any tracked file) to each so a fresh checkout includes it.")
+    return "\n".join(lines)
+
+
 def build_status_summary(request: StatusQueryRequest) -> StatusSummary:
     """Build a typed summary of the active session status."""
     with create_query_database_context(request.roar_dir) as db_ctx: