typedef-data-intelligence 0.34.0__tar.gz → 0.35.0__tar.gz

{typedef_data_intelligence-0.34.0 → typedef_data_intelligence-0.35.0}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.35.0](https://github.com/typedef-ai/typedef/compare/typedef-data-intelligence-v0.34.0...typedef-data-intelligence-v0.35.0) (2026-07-06)
+
+
+### Features
+
+* **desktop:** Airflow context-project discovery + multi-kind picker (TD-2647) ([#1079](https://github.com/typedef-ai/typedef/issues/1079)) ([0436af1](https://github.com/typedef-ai/typedef/commit/0436af1f8720643405921759be411ef39c783172))
+* **observability:** add session manifest core + call-site instrumentation (TD-3826) ([#1098](https://github.com/typedef-ai/typedef/issues/1098)) ([8c6406a](https://github.com/typedef-ai/typedef/commit/8c6406a5d31d4429e7dbe0de011361e8fa235239))
+
+
+### Bug Fixes
+
+* **desktop:** honor dbt subprojects in test home provisioning ([#1093](https://github.com/typedef-ai/typedef/issues/1093)) ([0064597](https://github.com/typedef-ai/typedef/commit/0064597f2fa74452356061a8f7d69b2158106eb0))
+* harden matrix sync completion validation ([#1096](https://github.com/typedef-ai/typedef/issues/1096)) ([afbc22e](https://github.com/typedef-ai/typedef/commit/afbc22eff571a69d56d6d764c6e79dc692d6cf96))
+* **ingest:** bound RTIF snapshot reader run selection (TD-3823) ([#1095](https://github.com/typedef-ai/typedef/issues/1095)) ([fff7d65](https://github.com/typedef-ai/typedef/commit/fff7d6510f7d54b029dadb29dfa4ef6958239162))
+
 ## [0.34.0](https://github.com/typedef-ai/typedef/compare/typedef-data-intelligence-v0.33.0...typedef-data-intelligence-v0.34.0) (2026-07-01)
 
 

{typedef_data_intelligence-0.34.0 → typedef_data_intelligence-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: typedef-data-intelligence
-Version: 0.34.0
+Version: 0.35.0
 Summary: Unified lineage management and AI-powered analytics platform for dbt projects
 Project-URL: Homepage, https://typedef.ai
 Project-URL: Repository, https://github.com/typedef-ai/data-intelligence

{typedef_data_intelligence-0.34.0 → typedef_data_intelligence-0.35.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "typedef-data-intelligence"
-version = "0.34.0"
+version = "0.35.0"
 description = "Unified lineage management and AI-powered analytics platform for dbt projects"
 readme = "README.pypi.md"
 license = "LicenseRef-Proprietary"

{typedef_data_intelligence-0.34.0 → typedef_data_intelligence-0.35.0}/src/lineage/api/app.py

@@ -326,6 +326,19 @@ async def lifespan(app: FastAPI):
                 len(removed_frontend_logs),
             )
 
+        try:
+            from core.observability.manifest import record_session_start
+            from core.observability.session import mint_session_id
+
+            mint_session_id()
+            record_session_start({})
+        except Exception as exc:
+            logger.warning(
+                "Observability session manifest startup failed: %s",
+                exc,
+                exc_info=True,
+            )
+
         # TD-3200 Phase 3: convert any already-workspaces-shape config from the
         # pre-envelope ContextEntry/flat-LineageTarget shape to the
         # ContextProject/BuildTarget envelope.  Operates only on
@@ -733,6 +746,13 @@ async def lifespan(app: FastAPI):
                 "Failed to terminate active gold workers", exc_info=True
             )
 
+    try:
+        from core.observability.manifest import finalize_open_ops
+
+        finalize_open_ops(outcome="cancelled")
+    except Exception:
+        logger.debug("Failed to finalize observability manifest ops", exc_info=True)
+
     try:
         from lineage.api.posthog_analytics import shutdown_shared_posthog_client
 

{typedef_data_intelligence-0.34.0 → typedef_data_intelligence-0.35.0}/src/lineage/api/desktop_quickstart.py

@@ -27,6 +27,8 @@ from typing import Any, Literal
 import yaml
 from agent.api import shutdown_event
 from core.backends.controlplane import LLMProxyConfig
+from core.models.observability import Outcome
+from core.observability.manifest import record_op_end, record_op_start
 from core.paths import (
     config_path,
     ensure_home,
@@ -144,6 +146,48 @@ _quickstart_ops: dict[str, QuickstartOperation] = {}
 _quickstart_lock = threading.Lock()
 
 
+def _quickstart_manifest_attrs() -> dict[str, str]:
+    return {
+        "project_name": QUICKSTART_PROJECT_NAME,
+        "display_name": QUICKSTART_DISPLAY_NAME,
+    }
+
+
+def _quickstart_manifest_outcome(status: str | None) -> Outcome:
+    if status == "error":
+        return "error"
+    if status == "cancelled":
+        return "cancelled"
+    return "ok"
+
+
+def _record_quickstart_start(quickstart_id: str) -> None:
+    record_op_start(
+        "setup",
+        "quickstart",
+        quickstart_id,
+        attrs=_quickstart_manifest_attrs(),
+    )
+
+
+def _record_quickstart_end(
+    quickstart_id: str,
+    outcome: Outcome,
+    *,
+    error: str | None = None,
+) -> None:
+    record_op_end("quickstart", quickstart_id, outcome, error=error)
+
+
+def _record_quickstart_event_end(quickstart_id: str, event: dict[str, Any]) -> None:
+    status = event.get("status")
+    outcome = _quickstart_manifest_outcome(str(status) if status is not None else None)
+    error = None
+    if outcome == "error":
+        error = str(event.get("message") or "Quick Start failed")
+    _record_quickstart_end(quickstart_id, outcome, error=error)
+
+
 def _get_quickstart_op(quickstart_id: str) -> QuickstartOperation | None:
     with _quickstart_lock:
         return _quickstart_ops.get(quickstart_id)
@@ -908,6 +952,7 @@ def _watch_quickstart_process(quickstart_id: str) -> None:
         if terminal_event is not None:
             current.status = str(terminal_event.get("status", "completed"))
             current.last_event = terminal_event
+            _record_quickstart_event_end(quickstart_id, terminal_event)
         else:
             current.status = "completed"
             current.last_event = {
@@ -919,6 +964,7 @@ def _watch_quickstart_process(quickstart_id: str) -> None:
                 ),
                 "status": "completed",
             }
+            _record_quickstart_end(quickstart_id, "ok")
     elif exit_code == 128 + signal.SIGTERM:
         # TD-3192: SIGTERM-handler exit (143) is a clean cancel /
         # shutdown, not a crash — surface as cancelled.
@@ -929,6 +975,7 @@ def _watch_quickstart_process(quickstart_id: str) -> None:
             ),
             "status": "cancelled",
         }
+        _record_quickstart_end(quickstart_id, "cancelled")
     else:
         current.status = "error"
         current.error = f"Quick Start process exited unexpectedly (code {exit_code})"
@@ -936,6 +983,7 @@ def _watch_quickstart_process(quickstart_id: str) -> None:
             **_stage_event("clone", "error", current.error, terminal=True),
             "status": "error",
         }
+        _record_quickstart_end(quickstart_id, "error", error=current.error)
 
 
 def _cleanup_quickstart_op(operation: QuickstartOperation, *, force: bool) -> None:
@@ -1098,10 +1146,12 @@ async def start_quickstart() -> QuickstartStartResponse:
             terminal_event_path=_terminal_event_path(quickstart_id),
         )
         _quickstart_ops[quickstart_id] = op
+        _record_quickstart_start(quickstart_id)
 
         try:
             proc.start()
-        except Exception:
+        except Exception as exc:
+            _record_quickstart_end(quickstart_id, "error", error=str(exc))
             _quickstart_ops.pop(quickstart_id, None)
             _delete_quickstart_project(previous_default_project)
             raise
@@ -1139,6 +1189,7 @@ async def quickstart_progress(quickstart_id: str):
     if op.status in {"completed", "error", "cancelled"} and op.last_event:
         _cleanup_op(op, force=True)
         last_event = op.last_event
+        _record_quickstart_event_end(quickstart_id, last_event)
 
         async def terminal_event():
             yield _sse_event(f"quickstart.{last_event['status']}", last_event)
@@ -1151,6 +1202,7 @@ async def quickstart_progress(quickstart_id: str):
             while not shutdown_event.is_set():
                 if op.status in {"completed", "error", "cancelled"}:
                     if op.last_event is not None:
+                        _record_quickstart_event_end(quickstart_id, op.last_event)
                         yield _sse_event(
                             f"quickstart.{op.last_event['status']}", op.last_event
                         )
@@ -1175,6 +1227,7 @@ async def quickstart_progress(quickstart_id: str):
                         op.last_event = event
                         if evt_status == "error":
                             op.error = str(event.get("message") or "Quick Start failed")
+                        _record_quickstart_event_end(quickstart_id, event)
                         break
 
                 now = time.time()
@@ -1192,26 +1245,34 @@ async def quickstart_progress(quickstart_id: str):
                         # TD-3192: SIGTERM-handler exit (143) — clean
                         # cancel / shutdown, not a crash.
                         op.status = "cancelled"
+                        op.last_event = {
+                            **_stage_event(
+                                "clone", "cancelled", "Quick Start cancelled"
+                            ),
+                            "status": "cancelled",
+                        }
+                        _record_quickstart_end(quickstart_id, "cancelled")
                         yield _sse_event(
                             "quickstart.cancelled",
-                            {
-                                **_stage_event(
-                                    "clone", "cancelled", "Quick Start cancelled"
-                                ),
-                                "status": "cancelled",
-                            },
+                            op.last_event,
                         )
                     else:
                         op.status = "error"
                         op.error = (
                             f"Quick Start process exited unexpectedly (code {exit_code})"
                         )
+                        op.last_event = {
+                            **_stage_event("clone", "error", op.error),
+                            "status": "error",
+                        }
+                        _record_quickstart_end(
+                            quickstart_id,
+                            "error",
+                            error=op.error,
+                        )
                         yield _sse_event(
                             "quickstart.error",
-                            {
-                                **_stage_event("clone", "error", op.error),
-                                "status": "error",
-                            },
+                            op.last_event,
                         )
                     break
         finally:
@@ -1298,6 +1359,7 @@ async def cancel_quickstart(quickstart_id: str):
     }
     if op.terminal_event_path is not None:
         _persist_terminal_event(op.terminal_event_path, op.last_event)
+    _record_quickstart_end(quickstart_id, "cancelled")
     _delete_quickstart_project(op.previous_default_project)
     _cleanup_quickstart_op(op, force=True)
     return {"message": f"Cancelled Quick Start '{quickstart_id}'"}

{typedef_data_intelligence-0.34.0 → typedef_data_intelligence-0.35.0}/src/lineage/api/desktop_setup.py

@@ -1053,6 +1053,8 @@ async def start_clone(req: CloneRequest):
     # repeat call with a different ``project_name`` (now reused as
     # ``display_name``) won't clobber the existing entry's display name.
     if dest.exists() and any(dest.iterdir()):
+        from core.observability.manifest import record_op_end, record_op_start
+
         _register_repo_pool_entry(req.git_url, dest, sanitized)
         _clone_ops[clone_id] = {
             "status": "complete",
@@ -1061,8 +1063,17 @@ async def start_clone(req: CloneRequest):
             "project_name": sanitized,
             "error": None,
         }
+        record_op_start(
+            "setup",
+            "clone",
+            clone_id,
+            attrs={"project_name": sanitized},
+        )
+        record_op_end("clone", clone_id, "ok")
         return CloneResponse(clone_id=clone_id)
 
+    from core.observability.manifest import record_op_start
+
     _clone_ops[clone_id] = {
         "status": "pending",
         "dest": dest,
@@ -1070,6 +1081,12 @@ async def start_clone(req: CloneRequest):
         "project_name": sanitized,
         "error": None,
     }
+    record_op_start(
+        "setup",
+        "clone",
+        clone_id,
+        attrs={"project_name": sanitized},
+    )
 
     # Spawn clone in background; register pool entry on success.
     asyncio.create_task(
@@ -1186,6 +1203,7 @@ async def _run_clone(
     project creations against the same URL hit the dedupe path in
     :func:`start_clone`.
     """
+    from core.observability.manifest import record_op_end
     from lineage.utils.git import clone_repo_with_progress
 
     _clone_ops[clone_id]["status"] = "running"
@@ -1195,6 +1213,12 @@ async def _run_clone(
             if progress.phase == "error":
                 _clone_ops[clone_id]["status"] = "error"
                 _clone_ops[clone_id]["error"] = progress.message
+                record_op_end(
+                    "clone",
+                    clone_id,
+                    "error",
+                    error=progress.message,
+                )
                 return
         _clone_ops[clone_id]["status"] = "complete"
         try:
@@ -1205,9 +1229,11 @@ async def _run_clone(
                 url,
                 exc,
             )
+        record_op_end("clone", clone_id, "ok")
     except Exception as exc:
         _clone_ops[clone_id]["status"] = "error"
         _clone_ops[clone_id]["error"] = str(exc)
+        record_op_end("clone", clone_id, "error", error=str(exc))
 
 
 @router.get("/clone/{clone_id}/progress")
@@ -4213,6 +4239,33 @@ async def _create_project(
 _preflight_clone_locks: dict[str, asyncio.Lock] = {}
 
 
+def _preview_preflight_manifest_outcome(
+    last_event: str | None,
+) -> tuple[Literal["ok", "error", "cancelled"], str | None]:
+    if last_event is None:
+        return "cancelled", None
+    event_type: str | None = None
+    payload: dict[str, Any] = {}
+    for line in last_event.splitlines():
+        if line.startswith("event: "):
+            event_type = line[len("event: ") :]
+        elif line.startswith("data: "):
+            try:
+                parsed = json.loads(line[len("data: ") :])
+            except json.JSONDecodeError:
+                parsed = {}
+            if isinstance(parsed, dict):
+                payload = parsed
+    if event_type is None:
+        return "cancelled", None
+    if event_type.endswith(".done"):
+        return "ok", None
+    if event_type.endswith(".error"):
+        message = payload.get("message")
+        return "error", message if isinstance(message, str) else None
+    return "cancelled", None
+
+
 async def _run_preflight_sse(
     *,
     adapter: str,
@@ -4701,6 +4754,18 @@ async def start_preview_preflight(req: PreviewPreflightRequest):
         raise HTTPException(status_code=400, detail=str(exc)) from exc
 
     async def generate():
+        from core.observability.manifest import record_op_end, record_op_start
+
+        record_op_start(
+            "setup",
+            "wizard_preflight",
+            req.session_id,
+            attrs={
+                "backend": req.backend,
+                "project_name": sanitized,
+            },
+        )
+        last_event: str | None = None
         tmp_profiles_dir = Path(tempfile.mkdtemp(prefix="typedef-preview-preflight-"))
         try:
             shutil.rmtree(scratch_root, ignore_errors=True)
@@ -4726,8 +4791,16 @@ async def start_preview_preflight(req: PreviewPreflightRequest):
                     and req.snowflake_inject_secondary_roles
                 ),
             ):
+                last_event = event
                 yield event
         finally:
+            outcome, error = _preview_preflight_manifest_outcome(last_event)
+            record_op_end(
+                "wizard_preflight",
+                req.session_id,
+                outcome,
+                error=error,
+            )
             shutil.rmtree(tmp_profiles_dir, ignore_errors=True)
 
     return StreamingResponse(generate(), media_type="text/event-stream")

{typedef_data_intelligence-0.34.0 → typedef_data_intelligence-0.35.0}/src/lineage/api/desktop_sync.py

@@ -25,6 +25,8 @@ from typing import TYPE_CHECKING, Any
 from agent.api import shutdown_event
 from agent.controlplane_context import get_typedef_context
 from core.backends.controlplane import LLMProxyConfig
+from core.models.observability import Outcome
+from core.observability.manifest import record_op_end, record_op_start
 from fastapi import APIRouter, Depends, HTTPException, Request
 from lineage.api.posthog_analytics import (
     backend_event_insert_id,
@@ -247,6 +249,7 @@ class SyncOperation:
     # loops cleanly.
     subscribers: set[Any] = field(default_factory=set)
     drain_task: Any | None = None
+    sync_project_started: set[str] = field(default_factory=set)
 
 
 @dataclass(frozen=True)
@@ -273,6 +276,76 @@ _sync_lock = threading.Lock()
 _op_state_lock = threading.Lock()
 
 
+def _sync_manifest_attrs(op: SyncOperation) -> dict[str, str]:
+    return {"workspace_name": op.workspace_name, "project_name": op.project_name}
+
+
+def _sync_project_manifest_attrs(project_name: str) -> dict[str, str]:
+    return {"project_name": project_name}
+
+
+def _sync_outcome(status: str | None) -> Outcome:
+    if status == "error":
+        return "error"
+    if status == "cancelled":
+        return "cancelled"
+    return "ok"
+
+
+def _sync_project_op_id(sync_id: str, project_name: str) -> str:
+    return f"{sync_id}/{project_name}"
+
+
+def _record_sync_start(op: SyncOperation) -> None:
+    record_op_start("sync", "sync", op.sync_id, attrs=_sync_manifest_attrs(op))
+
+
+def _record_sync_end(
+    sync_id: str,
+    outcome: Outcome,
+    *,
+    error: str | None = None,
+) -> None:
+    record_op_end("sync", sync_id, outcome, error=error)
+
+
+def _record_sync_event_end(sync_id: str, event: dict[str, Any]) -> None:
+    status = event.get("status")
+    outcome = _sync_outcome(str(status) if status is not None else None)
+    error = str(event.get("message") or "Sync failed") if outcome == "error" else None
+    _record_sync_end(sync_id, outcome, error=error)
+
+
+def _record_sync_project_start(op: SyncOperation, project_name: str) -> None:
+    if project_name in op.sync_project_started:
+        return
+    op.sync_project_started.add(project_name)
+    record_op_start(
+        "sync",
+        "sync_project",
+        _sync_project_op_id(op.sync_id, project_name),
+        parent_op_id=op.sync_id,
+        attrs=_sync_project_manifest_attrs(project_name),
+    )
+
+
+def _record_sync_project_end(
+    op: SyncOperation,
+    project_name: str,
+    outcome: Outcome,
+    *,
+    error: str | None = None,
+    artifacts: list[str] | None = None,
+) -> None:
+    record_op_end(
+        "sync_project",
+        _sync_project_op_id(op.sync_id, project_name),
+        outcome,
+        error=error,
+        artifacts=artifacts or [],
+    )
+
+
 def _get_sync_op(sync_id: str) -> SyncOperation | None:
     """Read a sync operation from the registry under the module lock."""
     with _sync_lock:
@@ -580,12 +653,26 @@ async def _drain_op_queue(op: SyncOperation) -> None:
 
             if event is not None:
                 evt_status = event.get("status", "running")
+                project_name = event.get("project")
+                if isinstance(project_name, str) and project_name:
+                    _record_sync_project_start(op, project_name)
+                    if event.get("stage") == "project_error":
+                        _record_sync_project_end(
+                            op,
+                            project_name,
+                            "error",
+                            error=str(event.get("message") or "sync failed"),
+                        )
                 # TD-3196: per-project completion inside a workspace build —
                 # persist THIS project's synced commit + build state (keyed on
                 # the event's ``project``), non-terminal so the batch's other
                 # projects + the final L1 pass keep streaming.
                 if event.get("stage") == "project_complete":
-                    _proj = event.get("project") or op.project_name
+                    _proj = (
+                        project_name
+                        if isinstance(project_name, str) and project_name
+                        else op.project_name
+                    )
                     try:
                         await asyncio.to_thread(
                             _persist_synced_commit,
@@ -639,6 +726,12 @@ async def _drain_op_queue(op: SyncOperation) -> None:
                             "failed for %s",
                             _proj,
                         )
+                    _record_sync_project_end(
+                        op,
+                        _proj,
+                        "ok",
+                        artifacts=[str(v) for v in (event.get("artifacts") or [])],
+                    )
                     _record_and_broadcast(op, event)
                     last_heartbeat = time.time()
                     continue
@@ -707,6 +800,7 @@ async def _drain_op_queue(op: SyncOperation) -> None:
                                 "[desktop:sync] _persist_target_build_state failed for %s",
                                 op.project_name,
                             )
+                    _record_sync_event_end(op.sync_id, event)
                 _record_and_broadcast(op, event)
                 if evt_status in ("completed", "error", "cancelled"):
                     break
@@ -739,6 +833,7 @@ async def _drain_op_queue(op: SyncOperation) -> None:
                             "total": 0,
                         },
                     )
+                    _record_sync_end(op.sync_id, "cancelled")
                 else:
                     op.status = "error"
                     op.error = f"Sync process exited unexpectedly (code {exit_code})"
@@ -752,6 +847,7 @@ async def _drain_op_queue(op: SyncOperation) -> None:
                             "total": 0,
                         },
                     )
+                    _record_sync_end(op.sync_id, "error", error=op.error)
                 break
     finally:
         # Tell every subscriber the stream is finished — they break
@@ -815,6 +911,7 @@ def _reap_dead_op_if_stale(op: SyncOperation) -> bool:
             op.sync_id,
             exc_info=True,
         )
+    _record_sync_end(op.sync_id, "error", error=op.error)
     _pop_sync_op(op.sync_id)
     return True
 
@@ -2353,7 +2450,7 @@ def _maybe_migrate_workspace_graph(
                     "stage": "migrate",
                     "current": current,
                     "total": total,
-                    "status": "running" if stage != "complete" else "completed",
+                    "status": "running",
                     "message": f"Upgrading lineage graph: {stage}",
                 }
             )
@@ -2370,7 +2467,7 @@ def _maybe_migrate_workspace_graph(
                 "stage": "migrate",
                 "current": cleared,
                 "total": cleared,
-                "status": "completed",
+                "status": "running",
                 "message": (
                     f"Lineage graph upgraded "
                     f"({cleared} context entr{'y' if cleared == 1 else 'ies'} "
@@ -2470,12 +2567,25 @@ def _build_one_project(
     from ingest.unified.stages.registry import get_stage_label
     from ingest.unified.stages.types import UnifiedPipelineConfig
 
-    config = UnifiedPipelineConfig.from_project_name(
-        project_name,
-        workspace_name=workspace_name,
-        full=full,
-        llm_proxy=llm_proxy,
-    )
+    try:
+        config = UnifiedPipelineConfig.from_project_name(
+            project_name,
+            workspace_name=workspace_name,
+            full=full,
+            llm_proxy=llm_proxy,
+        )
+    except ValueError as exc:
+        # TD-3823: a project's authored settings can fail integration-config
+        # validation (e.g. airflow.rtif_k_runs outside the reader's ceiling).
+        # This must stay a per-project failure — not caught here, it propagates
+        # past this function's own try/except below (which only wraps
+        # orchestrator.run()) straight out of the per-project loop in
+        # _sync_worker and aborts the WHOLE workspace batch, contradicting this
+        # function's own "per-project failures are non-fatal" contract.
+        log.exception("[%s] config parsing failed", project_name)
+        _capture_sync_failed_analytics(llm_proxy, analytics_context, sync_id, exc)
+        return _ProjectOutcome(status="error", error=str(exc) or type(exc).__name__)
+
     _apply_sync_run_overrides(config, run_overrides or SyncRunOverrides())
     # TD-3196: in a multi-project workspace build, skip the workspace-global
     # L1 concept rebuild on each per-project sync; the coordinator runs one
@@ -2562,6 +2672,7 @@ def _build_one_project(
                 "total": total,
                 "status": "running",
                 "message": get_stage_label(stage_name),
+                "project": project_name,
                 **_outer,
             }
         )
@@ -2576,6 +2687,7 @@ def _build_one_project(
             "total": 0,
             "status": "running",
             "message": "Starting sync pipeline",
+            "project": project_name,
             **_outer,
         }
     )
@@ -2913,6 +3025,7 @@ def _sync_worker(
                         "total": 0,
                         "status": "running",
                         "message": f"{spec.name}: {outcome.error or 'sync failed'}",
+                        "project": spec.name,
                         "outer_label": outer[0],
                         "outer_current": outer[1],
                         "outer_total": outer[2],
@@ -3523,11 +3636,17 @@ async def start_sync(req: SyncRequest, request: Request):
                 started_at=time.time(),
             )
             _sync_ops[sync_id] = op
+            _record_sync_start(op)
 
             # TD-3192: start the process INSIDE the lock so the shutdown
             # snapshot can't observe a registered-but-not-started op (which
             # would have a ``None`` pid and escape termination).
-            proc.start()
+            try:
+                proc.start()
+            except Exception as exc:
+                _record_sync_end(sync_id, "error", error=str(exc))
+                _sync_ops.pop(sync_id, None)
+                raise
 
     logger.info(
         "[desktop:sync] Started sync %s for project '%s' (pid=%d)",
@@ -3671,6 +3790,7 @@ async def cancel_sync(sync_id: str):
             pass  # nosec B110 — best-effort queue teardown
 
     op.status = "cancelled"
+    _record_sync_end(sync_id, "cancelled")
     logger.info("[desktop:sync] Cancelled sync %s", sync_id)
 
     # Remove from registry after brief delay