cdx-manager 0.25.1 → 0.25.3

package/src/commands/launch.py

@@ -36,7 +36,7 @@ from ..provider_runtime import (
 from ..run_command import PROMPT_STDIN, read_run_prompt
 from ..run_usage import estimate_cost, format_cache_ratio
 
-LAUNCH_USAGE = "Usage: cdx <name> [--dir PATH] [--prompt TEXT|--prompt-file PATH|--task TEXT [--end-state TEXT]] [--resume] [--on-busy fail|ask] [--json]"
+LAUNCH_USAGE = "Usage: cdx <name> [--dir PATH] [--project PATH] [--prompt TEXT|--prompt-file PATH|--task TEXT [--end-state TEXT]] [--resume] [--on-busy fail|ask] [--json]"
 
 #: The first message of a session started with --task. The end state is what the
 #: user's go-ahead covers: a bare "show me first" made sessions stop after a commit
@@ -206,6 +206,7 @@ def handle_can_resume(rest, ctx):
     return 0
 
 def handle_resume(rest, ctx):
+    project_path, rest = _pop_value_flag(rest, "--project", RESUME_USAGE)
     conversation_id, rest = _pop_value_flag(rest, "--conversation", RESUME_USAGE)
     directory, rest, prompt, on_busy = _parse_launch_args(rest)
     if prompt["prompt"] is not None or prompt["prompt_file"] is not None:
@@ -214,7 +215,7 @@ def handle_resume(rest, ctx):
     if len(args) != 1:
         raise CdxError(RESUME_USAGE)
     return handle_launch(args[0], ctx, resume=True, force_json=json_flag, directory=directory,
-                         conversation_id=conversation_id, on_busy=on_busy)
+                         conversation_id=conversation_id, on_busy=on_busy, project_path=project_path)
 
 
 def _notification_provisioning_enabled(session, ctx, json_flag):
@@ -258,7 +259,7 @@ def _link_shared_memory(session, ctx, cwd, json_flag):
 
 
 def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=None, directory=None,
-                  conversation_id=None, on_busy="ask"):
+                  conversation_id=None, on_busy="ask", project_path=None):
     json_flag = "--json" in ctx.get("raw_args", ctx["options"].get("raw_args", []))
     if force_json is not None:
         json_flag = force_json
@@ -278,7 +279,10 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
         raise CdxError(
             f"Provider {session['provider']} does not support native resume through cdx."
         )
+    from ..project_identity import resolve_project
+
     cwd = _launch_directory(session, ctx, directory, json_flag)
+    project = resolve_project(cwd, project_path)
     session = ctx["service"]["launch_session"](command, resume=resume)
     if conversation_id:
         session = with_requested_conversation(session, conversation_id)
@@ -330,7 +334,7 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
     def runtime_lifecycle(event, info):
         nonlocal runtime_run_id
         if event == "started":
-            runtime = ctx["service"]["start_session_runtime"](session["name"], {**info, "cwd": cwd})
+            runtime = ctx["service"]["start_session_runtime"](session["name"], {**info, "cwd": cwd, **project})
             runtime_run_id = runtime.get("runId")
         elif event == "finished" and runtime_run_id:
             ctx["service"]["finish_session_runtime"](
@@ -382,6 +386,8 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
                 "error": str(error),
                 "exit_code": error.exit_code,
                 **run_info,
+                **project,
+                "run_id": runtime_run_id,
             })
         raise
     success_run_info = _attach_interactive_usage(
@@ -395,13 +401,15 @@ def handle_launch(command, ctx, initial_prompt=None, resume=False, force_json=No
         "cwd": cwd,
         "exit_code": 0,
         **success_run_info,
+        **project,
+        "run_id": runtime_run_id,
     })
     if not json_flag:
         ctx["out"](f"{_goodbye_line(session, success_run_info, ctx['use_color'])}\n")
     if retro.start(session, cwd, success_run_info.get("provider_transcript_path"), env=ctx.get("env")) and not json_flag:
         ctx["out"](f"{_dim('Session retro started; read it later with `cdx retro`', ctx['use_color'])}\n")
     if json_flag:
-        extra = {"session": ctx["service"]["get_session"](session["name"]), "cwd": cwd}
+        extra = {"session": ctx["service"]["get_session"](session["name"]), "cwd": cwd, **project, "run_id": runtime_run_id}
         if capability:
             extra["resume"] = capability
         _write_json(ctx, _json_success("resume" if resume else "launch", message, warnings=warnings, **extra))

package/src/commands/runs.py

@@ -5,7 +5,6 @@ Split out of cli_commands.py. Moved verbatim; re-exported by cli_commands.
 
 import importlib.util
 import os
-import shutil
 import subprocess
 import sys
 import time
@@ -49,6 +48,7 @@ from ..provider_runtime import (
     _run_headless_provider_command,
     with_requested_conversation,
 )
+from ..remote_run import preflight, run_remote
 from ..run_command import read_run_prompt, run_cdx_error_code, run_launch_payload, run_result_payload
 from ..run_failover import (
     CAPACITY_RETRY_DELAYS,
@@ -58,7 +58,7 @@ from ..run_failover import (
     looks_model_at_capacity,
 )
 from ..run_registry import RunRegistry, build_code_review_report, final_message
-from ..run_usage import empty_usage, estimate_cost, extract_run_conversation_id, extract_run_observation, token_prices
+from ..run_usage import cost_fields, empty_usage, estimate_cost, extract_run_conversation_id, extract_run_observation, token_prices
 from ..session_ranking import FACTOR_DESCRIPTIONS, rank_sessions, selection_policy
 from ..status_view import _now_timestamp, _priority_reset_timestamp
 
@@ -204,6 +204,9 @@ def _detached_child_argv(parsed, prompt_path, session_name, cwd):
     # from the package root, so a relative "--cwd ." would resolve there.
     argv = ["run", session_name, "--cwd", cwd, "--prompt-file", prompt_path]
     for flag, key in (
+        ("--remote", "remote"),
+        ("--remote-prefix", "remote_prefix"),
+        ("--project", "project"),
         ("--budget", "budget"),
         ("--continue-run", "continue_run"),
         ("--model", "model"),
@@ -423,6 +426,8 @@ def _reconcile_background_runs(ctx):
                 "run_id": run["run_id"],
                 "attempt": 1,
                 "cwd": run.get("cwd"),
+                "project": run.get("project"),
+                "project_source": run.get("project_source", "unknown"),
                 "usage": outcome["usage"],
                 "usage_model": outcome["usage_model"],
             })
@@ -544,9 +549,19 @@ def _env_max_runs(ctx):
 
 
 def _observe_headless_usage(session, run_info, baseline=None):
-    usage, model = extract_run_observation(session.get("provider"), run_info.get("stdout_path"), session.get("authHome"))
-    observation = {"usage": usage, "usage_model": model}
-    if baseline is not None:
+    isolated = bool(run_info.get("remote")) or (session.get("launch") or {}).get("isolate_workspace")
+    evidence = run_info.get("usage_evidence")
+    observed_models = []
+    usage, model = extract_run_observation(session.get("provider"), run_info.get("stdout_path"),
+                                          None if isolated else session.get("authHome"), evidence=evidence, models_out=observed_models)
+    raw_measured = usage.get("total_tokens") is not None
+    observation = {"usage": usage, "usage_model": model, "usage_models": observed_models}
+    if evidence is not None:
+        observation["usage_evidence"] = evidence
+    if baseline is not None and isolated:
+        observation.update(usage=empty_usage(), usage_model=None, usage_attribution="continuation_usage_unavailable",
+                           measurement_unavailable=raw_measured)
+    elif baseline is not None:
         cumulative, path, match, transcript_model = extract_interactive_usage(
             session["provider"], session.get("authHome"), conversation_id=(session.get("conversation") or {}).get("id"))
         before, before_path, _before_match, _before_model = baseline
@@ -559,13 +574,18 @@ def _observe_headless_usage(session, run_info, baseline=None):
         # establish this run's share; stdout cannot replace a missing boundary.
         observation.update(usage=delta if delta is not None else empty_usage(), usage_cumulative=cumulative,
                            usage_attribution="launch_boundary" if delta is not None else "continuation_usage_unavailable",
+                           measurement_unavailable=delta is None and bool(raw_measured or (cumulative and cumulative.get("total_tokens") is not None)),
                            provider_transcript_path=path, provider_transcript_match=match,
-                           usage_model=model or transcript_model)
+                           usage_model=model if session.get("provider") == "codex" else model or transcript_model)
+    observation.update(cost_fields(observation["usage"], observation["usage_model"],
+                                   models=observed_models, attribution=observation.get("usage_attribution")))
     return observation
 
 
 def _budget_observation(session, paths, baseline):
     observation = _observe_headless_usage(session, paths, baseline if session["provider"] == "codex" else None)
+    if (session.get("launch") or {}).get("isolate_workspace"):
+        return observation
     identifier = (extract_run_conversation_id(session["provider"], paths.get("stdout_path"))
                   or ((session.get("conversation") or {}).get("id")
                       if session["provider"] == "claude" or session.get("continue_run") else None))
@@ -580,8 +600,14 @@ def _budget_observation(session, paths, baseline):
         comparable = (before and path == before_path
                       and all((usage.get(key) is None) == (before.get(key) is None) for key in MEASURED_KEYS))
         usage = usage_delta(usage, before, provider=session["provider"]) if comparable else None
+    if usage is not None and session["provider"] == "codex":
+        from ..run_usage import _codex_run_models
+        models = _codex_run_models([{"type": "thread.started", "thread_id": identifier}], session.get("authHome"))
+        model = next(iter(models)) if len(models) == 1 else None
     if usage is not None:
-        return {**observation, "usage": usage, "usage_model": model, "provider_transcript_path": path,
+        observed_models = sorted(models) if session["provider"] == "codex" else [model] if model else []
+        return {**observation, "usage": usage, "usage_model": model, "usage_models": observed_models,
+                **cost_fields(usage, model, models=observed_models), "provider_transcript_path": path,
                 "provider_transcript_match": match}
     return observation
 
@@ -629,6 +655,12 @@ def _continue_run_session(parsed, ctx):
             if arg.split("=", 1)[0] in pinned_options or arg.startswith(("-r", "-c")):
                 raise CdxError("--continue-run cannot use Claude extra_args that override model, effort, or conversation.",
                                code="continue_run_settings_mismatch")
+    from ..project_identity import recorded_project
+
+    project = recorded_project(previous)
+    if parsed.get("project") and parsed["project"] != project:
+        raise CdxError("--continue-run requires the previous run's recorded project.")
+    parsed["continued_project"] = {"project": project, "project_source": previous.get("project_source", "unknown")}
     parsed.update(name=name, model=model, reasoning_effort=effort, power=effort)
     launch = {**(session.get("launch") or {}), "model": model, "reasoning_effort": effort, "power": effort}
     # A provider fallback would break the model pin even though cdx stayed on this profile.
@@ -681,9 +713,27 @@ def handle_run(rest, ctx):
             session = selected["session"]
             selection_row = selected.get("row") or {}
 
+        remote_version = None
+        if parsed.get("remote"):
+            if session["provider"] != "codex":
+                raise CdxError("--remote is only available for Codex profiles.", code="remote_provider_unsupported")
+            if parsed.get("continue_run"):
+                raise CdxError("--remote requires a fresh run without --continue-run.")
+            remote_version = preflight(
+                parsed["remote"], {**os.environ, **(ctx.get("env") or {})},
+                remote_prefix=parsed.get("remote_prefix"), isolate_workspace=parsed.get("isolate_workspace", False),
+                cwd=parsed["cwd"], network=parsed.get("network_access", False), writable=parsed.get("permission") != "review")
         cwd = os.path.abspath(parsed["cwd"])
-        if not os.path.isdir(cwd):
+        if not parsed.get("remote") and not os.path.isdir(cwd):
             raise CdxError(f"Invalid cwd: {parsed['cwd']}", code="invalid_cwd")
+        from ..project_identity import resolve_project
+
+        project = parsed.get("continued_project") or resolve_project(cwd, parsed.get("project"))
+        if detached_run_id:
+            previous = _run_registry(ctx).get(detached_run_id)
+            if previous:
+                project = {"project": previous.get("project"), "project_source": previous.get("project_source", "unknown")}
+        parsed.update(project)
         prompt = read_run_prompt(parsed, stdin=ctx.get("prompt_stdin"))
         _consume_detached_prompt_file(parsed, detached_run_id)
         launch_updates = {key: parsed.get(key, False) for key in ("network_access", "isolate_workspace")}
@@ -716,17 +766,18 @@ def handle_run(rest, ctx):
                 **launch_updates,
             },
         }
-        _ensure_session_authentication(
-            run_session,
-            ctx["service"],
-            spawn=ctx.get("spawn"),
-            spawn_sync=ctx.get("spawn_sync"),
-            env_override=ctx.get("env"),
-            stdin_is_tty=False,
-            behavior="launch",
-            signal_emitter=ctx.get("signal_emitter"),
-            trust_local_credentials=False,
-        )
+        if not parsed.get("remote"):
+            _ensure_session_authentication(
+                run_session,
+                ctx["service"],
+                spawn=ctx.get("spawn"),
+                spawn_sync=ctx.get("spawn_sync"),
+                env_override=ctx.get("env"),
+                stdin_is_tty=False,
+                behavior="launch",
+                signal_emitter=ctx.get("signal_emitter"),
+                trust_local_credentials=False,
+            )
         registry = _run_registry(ctx)
         # A detached child is handed its parent's run_id so both agree on the
         # identity the launch payload already reported to the caller.
@@ -743,6 +794,7 @@ def handle_run(rest, ctx):
             provider=run_session.get("provider"),
             model=parsed.get("model") or ((run_session.get("launch") or {}).get("model")),
             cwd=cwd,
+            **project,
             artifacts={
                 "transcript_path": artifacts.get("transcript_path"),
                 "stdout_path": artifacts.get("stdout_path"),
@@ -750,6 +802,7 @@ def handle_run(rest, ctx):
             },
             label=parsed.get("label"),
             max_parallel=max_parallel,
+            remote=parsed.get("remote"),
             parent_run_id=parsed.get("continue_run"),
             conversation_id=(run_session.get("conversation") or {}).get("id") if run_session["provider"] == "claude" or parsed.get("continue_run") else None,
             launch=run_session.get("launch"),
@@ -797,30 +850,46 @@ def handle_run(rest, ctx):
         failover_error_code = None
         recovery_events = []
         attempt = 0
+        attempt_observations = []
         spent_usd = 0.0
         models = capacity_models(run_session)
         model_index = 0
         capacity_retries = 0
         while True:
             attempt += 1
-            baseline = extract_interactive_usage(
-                run_session["provider"], run_session.get("authHome"),
-                conversation_id=(run_session.get("conversation") or {}).get("id"),
-            ) if parsed.get("continue_run") and (run_session["provider"] == "codex" or parsed.get("budget")) else None
+            registry.record_attempt(run_id, _headless_artifact_paths(run_session, run_id=run_id, attempt=attempt))
+            baseline = None
+            if parsed.get("continue_run") and (run_session["provider"] == "codex" or parsed.get("budget")):
+                if (run_session.get("launch") or {}).get("isolate_workspace"):
+                    baseline = (None, None, None, None)
+                else:
+                    baseline = extract_interactive_usage(
+                        run_session["provider"], run_session.get("authHome"),
+                        conversation_id=(run_session.get("conversation") or {}).get("id"))
             attempt_cost = None
             budget_observation = None
+            budget_unverifiable = False
 
             def check_budget(paths, session=run_session, before=baseline, already_spent=spent_usd):
-                nonlocal attempt_cost, budget_observation
+                nonlocal attempt_cost, budget_observation, budget_unverifiable
                 observation = _budget_observation(session, paths, before)
                 cost = estimate_cost(observation["usage"], observation["usage_model"], budget_prices)
+                measured = observation["usage"].get("total_tokens") is not None or observation.get("measurement_unavailable", False)
+                if cost is None and measured:
+                    budget_unverifiable = True
+                    budget_observation = observation
+                    return True
                 if cost is not None:
                     if attempt_cost is None or cost >= attempt_cost:
                         attempt_cost = cost
                         budget_observation = observation
                 return attempt_cost is not None and already_spent + attempt_cost >= parsed["budget"]
 
-            run_info = _run_headless_provider_command(
+            runner = _run_headless_provider_command
+            if parsed.get("remote"):
+                def runner(*args, **kwargs):
+                    return run_remote(*args, target=parsed["remote"], version=remote_version, remote_prefix=parsed.get("remote_prefix"), **kwargs)
+            run_info = runner(
                 run_session,
                 cwd=cwd,
                 env_override=ctx.get("env"),
@@ -828,6 +897,7 @@ def handle_run(rest, ctx):
                 timeout_seconds=parsed.get("timeout_seconds"),
                 spawn=ctx.get("spawn_headless") or ctx.get("spawn"),
                 run_id=run_id,
+                attempt=attempt,
                 **({"budget_check": check_budget} if parsed.get("budget") is not None else {}),
             )
             observation = _observe_headless_usage(run_session, run_info, baseline if run_session["provider"] == "codex" else None)
@@ -843,8 +913,20 @@ def handle_run(rest, ctx):
                         "recovery_events": recovery_events}
             cost = estimate_cost(observation["usage"], observation["usage_model"], budget_prices)
             spent_usd += max(attempt_cost or 0.0, cost or 0.0)
-            if parsed.get("budget") is not None and (run_info.get("budget_exceeded") or spent_usd >= parsed["budget"]):
+            if parsed.get("budget") is not None and (budget_unverifiable or (
+                    cost is None and (observation["usage"].get("total_tokens") is not None or observation.get("measurement_unavailable")))):
+                run_info.update(budget_unverifiable=True, budget_exceeded=False, returncode=125,
+                                cost_usd=None, cost_status="unknown", budget_status="unverifiable")
+            elif parsed.get("budget") is not None and (run_info.get("budget_exceeded") or spent_usd >= parsed["budget"]):
                 run_info.update(budget_exceeded=True, returncode=125, cost_usd=spent_usd)
+            attempt_observations.append({
+                "attempt": attempt, "attempt_id": run_info.get("attempt_id"),
+                "session": run_session["name"], "provider": run_session["provider"],
+                **{key: run_info.get(key) for key in ("usage", "usage_model", "usage_models", "usage_evidence")},
+                **cost_fields(observation["usage"], observation["usage_model"], budget_prices,
+                              models=observation.get("usage_models", []), attribution=observation.get("usage_attribution")),
+            })
+            run_info["attempts"] = list(attempt_observations)
             ctx["service"]["record_launch_history"](run_session["name"], {
                 "status": "success" if run_info.get("returncode") == 0 else "failed",
                 "action": "run",
@@ -853,8 +935,9 @@ def handle_run(rest, ctx):
                 "cwd": cwd,
                 "exit_code": run_info.get("returncode"),
                 **run_info,
+                **project,
             })
-            if run_info.get("budget_exceeded") or parsed.get("continue_run"):
+            if parsed.get("remote") or run_info.get("budget_exceeded") or run_info.get("budget_unverifiable") or parsed.get("continue_run"):
                 break
             if looks_model_at_capacity(run_session.get("provider"), run_info):
                 event = {"reason": "model_at_capacity", "attempt": attempt,
@@ -979,7 +1062,10 @@ def handle_run(rest, ctx):
             )
             _write_json(ctx, final_payload)
             return 0
-        if run_info.get("budget_exceeded"):
+        if run_info.get("budget_unverifiable"):
+            failover_error_code = "budget_unverifiable"
+            message = "Measured usage cannot be priced; USD budget enforcement is unavailable. Check cost_reason and observed model evidence."
+        elif run_info.get("budget_exceeded"):
             failover_error_code = "budget_exceeded"
             message = "Run exceeded its estimated USD budget."
         elif failover_error_code == "capacity_recovery_exhausted":
@@ -1000,7 +1086,7 @@ def handle_run(rest, ctx):
             run_session,
             run_info=run_info,
             error=error,
-            error_source="cdx" if run_info.get("budget_exceeded") else "provider",
+            error_source="cdx" if run_info.get("budget_exceeded") or run_info.get("budget_unverifiable") else "provider",
             # Running out of accounts is a different outcome from the task
             # failing, and a caller has to be able to branch on which happened.
             error_code=failover_error_code or (
@@ -1038,6 +1124,7 @@ def handle_run(rest, ctx):
                 "cwd": cwd,
                 "exit_code": error.exit_code,
                 **run_info,
+                **project,
             })
         final_payload = run_result_payload(
             API_SCHEMA_VERSION,
@@ -1065,14 +1152,10 @@ def handle_run(rest, ctx):
         return error.exit_code
 
 def _record_capacity_recovery(ctx, registry, run_id, event, run_info, events):
-    # Subsequent attempts reuse the run's paths; retain the failed output first.
-    artifacts = {}
-    for key in ("stdout_path", "stderr_path", "transcript_path"):
-        path = run_info.get(key)
-        if path and os.path.isfile(path):
-            archived = f"{path}.attempt-{event['attempt']}"
-            shutil.copyfile(path, archived)
-            artifacts[key] = archived
+    # Attempt paths are immutable; recovery events reference the same evidence
+    # as the history row instead of copying output that a retry will overwrite.
+    artifacts = {key: run_info[key] for key in ("stdout_path", "stderr_path", "transcript_path")
+                 if run_info.get(key) and os.path.isfile(run_info[key])}
     event["artifacts"] = artifacts
     events.append(event)
     registry.record_recovery(run_id, event)

package/src/commands/status.py

@@ -55,6 +55,7 @@ from ..rtk_savings import rtk_saved
 from ..run_usage import (
     TOKEN_USAGE_KEYS,
     cache_hit_ratio,
+    cost_fields,
     estimate_cost,
     format_cache_ratio,
     is_vouched,
@@ -287,6 +288,7 @@ def _summarize_stats(entries):
             "unweighted_runs": 0,
             "priced_runs": 0,
             "unpriced_models": set(),
+            "unpriced_reasons": {},
             "unvouched_runs": 0,
             "input_tokens": 0,
             "cached_input_tokens": 0,
@@ -342,7 +344,10 @@ def _summarize_stats(entries):
             if cost is not None:
                 row["cost_usd"] += cost
                 row["priced_runs"] += 1
-            elif entry.get("usage_model"):
+            else:
+                reason = cost_fields(usage, entry.get("usage_model"), models=entry.get("usage_models", (entry.get("usage_evidence") or {}).get("models", [])), attribution=entry.get("usage_attribution"))["cost_reason"]
+                row["unpriced_reasons"][reason] = row["unpriced_reasons"].get(reason, 0) + 1
+            if cost is None and entry.get("usage_model"):
                 # Named the model but could not price it. Recording which one
                 # turns an unexplained "-" into something actionable: that
                 # string is exactly what CDX_TOKEN_PRICES needs a key for.
@@ -524,9 +529,11 @@ def _format_rtk_saved(rtk):
 
 
 def _stats_group(entry, by):
-    """The project (launch folder) or the model a run is counted under."""
+    """The recorded source repository or serving model a run is counted under."""
     if by == "project":
-        return str(entry.get("cwd") or "").rstrip("/\\") or "-"
+        from ..project_identity import recorded_project
+
+        return recorded_project(entry) or "-"
     model = entry.get("usage_model") or "-"
     return model.removesuffix("[1m]") if model.startswith("claude-") else model
 
@@ -640,6 +647,26 @@ def handle_configs(rest, ctx):
     return 0
 
 def handle_history(rest, ctx):
+    if rest and rest[0] == "backfill-projects":
+        usage = "Usage: cdx history backfill-projects [--mapping FILE] [--dry-run | --apply] [--json]"
+        parsed = _parse_flag_args(rest[1:], {
+            "--mapping": {"key": "mapping", "type": "str", "default": None},
+            "--dry-run": {"key": "dry_run", "type": "bool", "default": False},
+            "--apply": {"key": "apply", "type": "bool", "default": False},
+            "--json": {"key": "json", "type": "bool", "default": False},
+        }, usage)
+        if parsed["apply"] and parsed["dry_run"]:
+            raise CdxError(usage)
+        result = ctx["service"]["backfill_history_projects"](mapping_path=parsed["mapping"], dry_run=not parsed["apply"])
+        if parsed["json"]:
+            payload = (_json_failure("history", "project_attribution_conflict", "Conflicting project evidence; no changes applied.", **result)
+                       if result["conflicting"] else _json_success("history", "Backfilled history projects", **result))
+            _write_json(ctx, payload)
+        else:
+            mode = "Dry run" if result["dry_run"] else "Not applied (conflicts)" if result["conflicting"] else "Applied"
+            ctx["out"](f"{mode}: {result['recovered']} recovered; {result['unchanged']} unchanged; "
+                       f"{result['unresolved']} unresolved; {result['conflicting']} conflicting.\n")
+        return 1 if result["conflicting"] else 0
     if rest and rest[0] == "backfill-models":
         usage = "Usage: cdx history backfill-models [--dry-run | --apply] [--json]"
         parsed = _parse_flag_args(rest[1:], {
@@ -672,7 +699,8 @@ def handle_history(rest, ctx):
     entries = ctx["service"]["get_launch_history"](parsed["name"], limit=limit)
     entries = _filter_history_period(entries, parsed["period"])
     entries = [{**entry, "parent_run_id": entry.get("parent_run_id"),
-                "cost_usd": estimate_cost(entry.get("usage"), entry.get("usage_model")) if is_vouched(entry.get("usage")) else None,
+                **cost_fields(entry.get("usage") if is_vouched(entry.get("usage")) else None, entry.get("usage_model"),
+                              models=entry.get("usage_models", (entry.get("usage_evidence") or {}).get("models", [])), attribution=entry.get("usage_attribution")),
                 "usage": {**entry["usage"], "cache_hit_ratio": cache_hit_ratio(entry["usage"], provider=entry.get("provider")) if is_vouched(entry["usage"]) else None}
                 if isinstance(entry.get("usage"), dict) else entry.get("usage")} for entry in entries]
     if has_period and not parsed["summary"]:

package/src/history_models.py

@@ -7,7 +7,7 @@ import time
 from .interactive_usage import MAX_TRANSCRIPT_BYTES, MAX_TRANSCRIPT_SCAN_SECONDS
 from .run_registry import registry_path
 
-EVIDENCE_KINDS = ("stdout", "run_report", "codex_rollout", "claude_transcript")
+EVIDENCE_KINDS = ("isolated_observation", "stdout", "run_report", "codex_rollout", "claude_transcript")
 
 
 def missing_model(value):
@@ -108,6 +108,15 @@ def _exact_transcript(provider, auth_home, identifier):
 def recover_model(entry, session=None, reports=()):
     """Return (model, evidence kind, reason); never consult live model settings."""
     provider = entry.get("provider")
+    evidence = entry.get("usage_evidence")
+    if isinstance(evidence, dict):
+        if (evidence.get("stdout_path") != entry.get("stdout_path")
+                or evidence.get("attempt_id") != entry.get("attempt_id")
+                or evidence.get("run_id") != entry.get("run_id")
+                or (evidence.get("measurement_usage") or evidence.get("usage")) != entry.get("usage")):
+            return None, "isolated_observation", "observation_attempt_mismatch"
+        model, reason = _single_model(evidence.get("models") or [])
+        return model, "isolated_observation", reason or (None if model else "no_turn_models")
     records, error = _read_records(entry.get("stdout_path"))
     if error:
         return None, None, error

package/src/project_identity.py

@@ -0,0 +1,71 @@
+"""Repository attribution captured by the trusted launcher, separate from cwd."""
+
+import json
+import ntpath
+import os
+import posixpath
+import subprocess
+from pathlib import PureWindowsPath
+
+from .errors import CdxError
+from .tray_logics import _repository_root
+
+PROJECT_SOURCES = {"git", "operator", "operator_mapping", "run_report"}
+
+
+def canonical_project(value):
+    """Validate recorded identities without consulting a possibly deleted checkout."""
+    return (isinstance(value, str) and bool(value.strip()) and "\x00" not in value
+            and ((posixpath.isabs(value) and posixpath.normpath(value) == value)
+                 or (PureWindowsPath(value).is_absolute() and ntpath.normpath(value) == value)))
+
+
+def recorded_project(entry):
+    value = entry.get("project")
+    source = entry.get("project_source")
+    return value if canonical_project(value) and isinstance(source, str) and source in PROJECT_SOURCES else None
+
+
+def resolve_project(cwd, explicit=None):
+    """Resolve before isolation. Never infer clone provenance from remote URLs."""
+    if explicit is not None:
+        if not canonical_project(explicit):
+            raise CdxError("--project must be an absolute canonical source repository path.")
+        return {"project": explicit, "project_source": "operator"}
+    root = _repository_root(cwd)
+    if root:
+        if os.path.isdir(os.path.join(root, ".git")):
+            return {"project": root, "project_source": "git"}
+        try:
+            # Ignore ambient Git overrides: this lookup belongs to the launch cwd.
+            env = {key: value for key, value in os.environ.items() if not key.startswith("GIT_")}
+            common = subprocess.run(["git", "-C", root, "rev-parse", "--git-common-dir"],
+                                    env=env, capture_output=True, text=True, timeout=5, check=True).stdout.strip()
+            common = os.path.realpath(os.path.join(root, common))
+            if os.path.isdir(common):
+                return {"project": os.path.dirname(common) if os.path.basename(common) == ".git" else common,
+                        "project_source": "git"}
+        except (OSError, subprocess.SubprocessError):
+            pass
+    return {"project": None, "project_source": "unknown"}
+
+
+def load_mapping(path):
+    try:
+        with open(path, encoding="utf-8") as handle:
+            data = json.load(handle)
+    except (OSError, ValueError) as error:
+        raise CdxError(f"Cannot read project mapping: {error}") from error
+    if (not isinstance(data, dict) or set(data) != {"version", "projects"}
+            or type(data["version"]) is not int or data["version"] != 1 or not isinstance(data["projects"], list)):
+        raise CdxError("Invalid project mapping: expected version 1 and a projects array.")
+    projects = {}
+    for item in data["projects"]:
+        if (not isinstance(item, dict) or set(item) != {"run_id", "project"}
+                or not isinstance(item["run_id"], str) or not item["run_id"].strip()
+                or not canonical_project(item["project"])):
+            raise CdxError("Invalid project mapping: each entry needs an exact run_id and absolute canonical project path.")
+        if item["run_id"] in projects and projects[item["run_id"]] != item["project"]:
+            raise CdxError(f"Conflicting project mappings for run {item['run_id']}.")
+        projects[item["run_id"]] = item["project"]
+    return projects