interlaced 2.1.0__tar.gz → 2.2.0__tar.gz

{interlaced-2.1.0/src/interlaced.egg-info → interlaced-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlaced
-Version: 2.1.0
+Version: 2.2.0
 Summary: Python/SQL-first data platform: transformation, built-in orchestration, and durable streaming ingestion
 Author-email: Mark <mark@interlace.sh>
 License-Expression: MIT

{interlaced-2.1.0 → interlaced-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlaced"
-version = "2.1.0"
+version = "2.2.0"
 description = "Python/SQL-first data platform: transformation, built-in orchestration, and durable streaming ingestion"
 readme = "README.md"
 requires-python = ">=3.12"

{interlaced-2.1.0 → interlaced-2.2.0}/src/interlace/cli/main.py

@@ -252,7 +252,8 @@ def init(
         table.add_column("Description", style="dim")
         table.add_column("Needs", style="dim")
         for info in list_templates():
-            table.add_row(info.name, info.description, ", ".join(info.requires_env) or "—")
+            # escape: a description may contain [sources]-style brackets Rich would eat as markup
+            table.add_row(info.name, escape(info.description), ", ".join(info.requires_env) or "—")
         console.print(table)
         return
     try:

{interlaced-2.1.0 → interlaced-2.2.0}/src/interlace/dsl/decorators.py

@@ -22,7 +22,7 @@ ModelFn = Callable[..., Any]
 # (a fingerprinted snapshot read through an environment view); `table`/`file` are
 # terminal deliveries into a destination interlace does not own.
 _MATERIALISATIONS = frozenset({"virtual", "view", "ephemeral", "table", "file"})
-_KEYED_STRATEGIES = frozenset({"merge", "full_merge", "scd"})
+_KEYED_STRATEGIES = frozenset({"merge", "full_merge", "hash_merge", "scd"})
 _DRIFT_MODES = frozenset({"evolve", "reject", "quarantine"})
 
 

{interlaced-2.1.0 → interlaced-2.2.0}/src/interlace/plan/apply.py

@@ -38,6 +38,7 @@ from interlace.state.interval import Interval
 from interlace.state.store import StateStore
 from interlace.strategies import Strategy, resolve_strategy
 from interlace.strategies.base import RowCounts
+from interlace.strategies.hash_merge import HashMerge
 
 
 @dataclass
@@ -107,6 +108,10 @@ async def _merge_python_output(
         pre_statements, source, columns = await _align_stage_to_target(
             engine, stage, target, exclude=strategy.managed_columns
         )
+    elif isinstance(strategy, HashMerge):
+        # hash_merge builds its _hash from the column list; on the first build the target
+        # doesn't exist yet (so no align pass ran), so take the columns from the staged output
+        columns = [c for c in await engine.describe(stage) if c not in strategy.managed_columns]
 
     relation = SqlRelation(ast=source)
     statements = strategy.plan_statements(relation, target, engine.caps, None, columns)
@@ -409,6 +414,21 @@ async def _run_backfill(
     target_engine = registry.require(model.engine, model=model.name)
     resolution = await _stage_cross_engine_inputs(model, compiled, registry, physical, staged, stage_lock, result)
 
+    if task.reuse_existing and await target_engine.table_exists(snapshot.physical_table):
+        # fingerprint already materialised (e.g. by another environment): the content-
+        # addressed table exists, so skip the (re)build compute — record the snapshot for
+        # this env's promotion, gate on checks against the existing table, and let the
+        # caller swap this environment's view onto the shared table. The table_exists guard
+        # is what makes the differ's optimistic reuse safe: a snapshot row can outlive its
+        # table (an in-memory warehouse across processes, a gc'd table) — then we fall
+        # through and build for real.
+        await state.add_snapshot(snapshot)  # idempotent — the row may already exist
+        if snapshot.name not in result.built and snapshot.name not in result.reused:
+            result.reused.append(snapshot.name)
+        await _gate_checks(model, compiled, target_engine, state, plan.environment, result, resolution)
+        result.timings[snapshot.name] = result.timings.get(snapshot.name, 0.0) + (time.perf_counter() - task_started)
+        return
+
     if model.ast is None:  # Python model: run the function, load Arrow into the snapshot table
         if model.materialise != "virtual":
             raise PlanError(
@@ -669,7 +689,10 @@ async def apply(
 
     mapping = {name: compiled.models[name].fingerprint for name in plan.promote}
     await state.promote(plan.environment, mapping)
-    result.promoted = len(mapping)
+    # ephemeral models are tracked in the mapping (so re-plans stay clean) but are inlined
+    # into consumers — they have no promotable table/view, so the user-facing count omits
+    # them, keeping "promoted N" consistent with the N build rows shown
+    result.promoted = sum(1 for name in mapping if compiled.models[name].materialise != "ephemeral")
 
     # deleted models: drop their env view and demote them, or the view serves the
     # last snapshot forever and pins it against gc

{interlaced-2.1.0 → interlaced-2.2.0}/src/interlace/plan/differ.py

@@ -243,7 +243,7 @@ def _schedule_reuse(plan: Plan, model: CompiledModel, previous: Snapshot, enviro
         )
 
 
-_HISTORY_STRATEGIES = frozenset({"merge", "full_merge", "scd", "incremental_by_time"})
+_HISTORY_STRATEGIES = frozenset({"merge", "full_merge", "hash_merge", "scd", "incremental_by_time"})
 """Strategies whose targets accumulate state a rebuild would destroy."""
 
 
@@ -303,6 +303,13 @@ async def diff(
         for name, fingerprint in current.items()
         if name in compiled.models and fingerprint != compiled.models[name].fingerprint
     )
+    # Fingerprints already materialised (by any prior apply — most usefully another
+    # environment): building these again would recompute an identical, content-addressed
+    # table, so schedule a reuse (record + view-swap) instead of a rebuild.
+    already_built = await state.get_snapshots((name, compiled.models[name].fingerprint) for name in selected)
+
+    def is_materialised(model: CompiledModel) -> bool:
+        return (model.name, model.fingerprint) in already_built
 
     for model in compiled.ordered():  # topo order: upstream impact known before downstream
         previous_fingerprint = current.get(model.name)
@@ -311,7 +318,13 @@ async def diff(
             impact[model.name] = "semantic"
             if model.name in selected:
                 plan.changes.append(ModelChange(model.name, ChangeType.ADDED, None, None, model.fingerprint))
-                schedule_build(plan, model, snapshot_of(model, ChangeCategory.BREAKING), environment)
+                schedule_build(
+                    plan,
+                    model,
+                    snapshot_of(model, ChangeCategory.BREAKING),
+                    environment,
+                    reuse_existing=is_materialised(model),
+                )
             continue
 
         if previous_fingerprint == model.fingerprint:
@@ -373,7 +386,9 @@ async def diff(
             )
             schedule_build(plan, model, snapshot, environment, seed_from=previous.physical_table)  # type: ignore[union-attr]
         elif rebuild:
-            schedule_build(plan, model, snapshot_of(model, category), environment)
+            schedule_build(
+                plan, model, snapshot_of(model, category), environment, reuse_existing=is_materialised(model)
+            )
         else:
             _schedule_reuse(plan, model, previous, environment)  # type: ignore[arg-type]  # previous is not None here
 

{interlaced-2.1.0 → interlaced-2.2.0}/src/interlace/plan/plan.py

@@ -55,6 +55,10 @@ class BackfillTask:
     # the strategy runs — history moves to the new fingerprint, the old table stays
     # as the rollback until gc.
     seed_from: TableRef | None = None
+    # This exact fingerprint is already materialised (a prior apply, often in another
+    # environment): the physical table exists and its content is fingerprint-pinned, so
+    # apply skips the build compute and only gates checks + swaps this env's view.
+    reuse_existing: bool = False
 
 
 @dataclass(frozen=True)
@@ -121,7 +125,13 @@ def env_view(environment: str, model_name: str) -> TableRef:
 
 
 def schedule_build(
-    plan: Plan, model: CompiledModel, snapshot: Snapshot, environment: str, *, seed_from: TableRef | None = None
+    plan: Plan,
+    model: CompiledModel,
+    snapshot: Snapshot,
+    environment: str,
+    *,
+    seed_from: TableRef | None = None,
+    reuse_existing: bool = False,
 ) -> None:
     """Add the right tasks for a model: ephemeral builds nothing; a terminal
     table/file builds (delivers) but gets no environment view; a virtual/view model
@@ -130,7 +140,14 @@ def schedule_build(
     An incremental_by_time model (virtual, or a terminal ``table``) cannot build
     without a window, so an apply fills the latest grain interval — the same default
     as ``interlace run`` — leaving history to ``run --start/--end``.
+
+    ``reuse_existing`` (the fingerprint is already materialised) skips the compute for a
+    plain virtual/view build — never for a terminal delivery, a forward-only seed, or an
+    incremental window, which must always run.
     """
+    # only a plain (non-seeded, non-windowed) virtual/view build can skip its compute:
+    # a terminal always delivers, a seed must copy history, an interval must fill
+    reuse = reuse_existing and seed_from is None and model.materialise in ("virtual", "view")
     if model.materialise == "ephemeral":  # inlined into consumers, never built
         return
     wants_view = model.materialise in ("virtual", "view")  # terminal table/file has no env view
@@ -164,7 +181,7 @@ def schedule_build(
         plan.backfills.append(BackfillTask(snapshot=snapshot, interval=window, seed_from=seed_from))
         add_view()
         return
-    plan.backfills.append(BackfillTask(snapshot=snapshot, seed_from=seed_from))
+    plan.backfills.append(BackfillTask(snapshot=snapshot, seed_from=seed_from, reuse_existing=reuse))
     add_view()
 
 

{interlaced-2.1.0 → interlaced-2.2.0}/src/interlace/service/app.py

@@ -4,9 +4,10 @@ A read + trigger surface over a project: list/inspect models, preview a plan
 (with per-change SQL + impacted columns), apply it (build changed snapshots and
 promote — guarded against breaking changes unless forced), inspect environments,
 list/inspect runs, and enqueue runs onto the durable queue (a running ``interlace
-scheduler`` drains them). The project is loaded and compiled once at startup and
-held on app state; the warehouse engine and control-plane store are opened for
-the app's lifetime. msgspec structs are the wire types (Litestar serialises them
+scheduler`` drains them). The project is compiled at startup and recompiled on
+demand when a model file changes on disk (see ``reload_if_stale``), so a Plan/Apply
+from the UI reflects live edits — matching what ``interlace plan`` shows; the
+warehouse engine and control-plane store are opened for the app's lifetime. msgspec structs are the wire types (Litestar serialises them
 natively). Scoped API-key auth is enforced once a key exists (see auth.py), and
 OpenAPI docs render via Scalar at ``/schema/scalar``.
 """
@@ -57,6 +58,52 @@ from interlace.streaming.materializer import (
 )
 from interlace.streaming.schema import partition_rows, validate_rows, validate_rows_evolve
 
+# ---- live reload ---------------------------------------------------------------
+# The project is compiled once at startup, then recompiled on demand when a model
+# file changes on disk — so editing a `.sql`/`.py` model and pressing Plan/Apply in
+# the UI reflects the edit, matching what `interlace plan` (a fresh process) shows.
+# Only the model graph is re-derived; changing engine/stream/path topology in
+# interlace.yaml still needs a daemon restart.
+
+
+def _source_mtime(root: Path, model_paths: list[str]) -> float:
+    """Newest mtime across the config file and every model source. Cheap staleness
+    probe (a stat walk); recompile only happens when this advances."""
+    from interlace.config.config import CONFIG_FILE
+
+    latest = 0.0
+    config = root / CONFIG_FILE
+    if config.exists():
+        latest = config.stat().st_mtime
+    for relative in model_paths:
+        base = root / relative
+        if not base.is_dir():
+            continue
+        for file in base.rglob("*"):
+            if file.suffix in (".sql", ".py") and file.is_file():
+                latest = max(latest, file.stat().st_mtime)
+    return latest
+
+
+async def reload_if_stale(state: State) -> None:
+    """Recompile from disk if any model source changed since the last compile.
+
+    Serialised by a lock so concurrent requests recompile at most once, and a
+    no-op (one stat walk) when nothing changed. Refreshes only the compile-derived
+    state — the graph, whole-project lineage, stream→consumer map — and clears the
+    describe cache (new fingerprints mean new tables to re-describe)."""
+    async with state.reload_lock:
+        mtime = await asyncio.to_thread(_source_mtime, state.root, state.model_paths)
+        if mtime <= state.source_mtime:
+            return
+        project = await asyncio.to_thread(Project.load, state.root)
+        compiled = await asyncio.to_thread(project.compile)
+        state.compiled = compiled
+        state.lineage = column_lineage(compiled)
+        state.stream_consumer_map = {name: sorted(stream_consumers(compiled, name)) for name in state.streams}
+        state.describe_cache = {}
+        state.source_mtime = mtime
+
 
 class ModelInfo(msgspec.Struct):
     name: str
@@ -71,6 +118,7 @@ class ModelInfo(msgspec.Struct):
     schedule: dict[str, str] | None
     engine: str = "default"
     language: str = "sql"  # "sql" | "python"
+    has_checks: bool = False  # declares SQL or Python checks — the runs view flags per-model check status
 
 
 class ModelDetail(msgspec.Struct):
@@ -123,6 +171,8 @@ class RunInfo(msgspec.Struct):
     # how the run came to be — the enqueue key's prefix names the trigger
     # (cron: / interval: / api: / stream:)
     idempotency_key: str | None = None
+    environment: str | None = None  # the env it built into (once it has succeeded)
+    duration: float | None = None  # wall-clock seconds, run.started → terminal
 
 
 class CreateRun(msgspec.Struct):
@@ -184,6 +234,8 @@ class ApplyResponse(msgspec.Struct):
     # per-model row movement (inserted/updated/deleted) and build seconds
     rows: dict[str, dict[str, int]] = msgspec.field(default_factory=dict)
     timings: dict[str, float] = msgspec.field(default_factory=dict)
+    gated: list[str] = msgspec.field(default_factory=list)  # terminals recorded but not delivered (env gate)
+    checks: list[CheckOutcomeInfo] = msgspec.field(default_factory=list)  # so a UI apply can show check results
 
 
 class CheckResultInfo(msgspec.Struct):
@@ -371,7 +423,7 @@ def _output(model: CompiledModel) -> str:
     return model.materialise
 
 
-def _info(model: CompiledModel) -> ModelInfo:
+def _info(model: CompiledModel, has_checks: bool = False) -> ModelInfo:
     return ModelInfo(
         name=model.name,
         output=_output(model),
@@ -385,6 +437,7 @@ def _info(model: CompiledModel) -> ModelInfo:
         schedule=model.schedule,
         engine=model.engine,
         language="python" if model.ast is None else "sql",
+        has_checks=has_checks,
     )
 
 
@@ -400,12 +453,17 @@ async def ui_redirect() -> Redirect:
 
 @get("/models")
 async def get_models(state: State) -> list[ModelInfo]:
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
-    return [_info(compiled.models[name]) for name in compiled.graph.topological_sort()]
+    return [
+        _info(compiled.models[name], bool(compiled.models[name].checks) or bool(compiled.python_checks.get(name)))
+        for name in compiled.graph.topological_sort()
+    ]
 
 
 @get("/models/{name:str}")
 async def get_model(name: FromPath[str], state: State) -> ModelDetail:
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
     if name not in compiled.models:
         raise NotFoundException(detail=f"unknown model: {name}")
@@ -437,6 +495,7 @@ async def get_model_impact(name: FromPath[str], state: State, column: FromQuery[
     transitively derived from it, plus opaque consumers (Python / ``*`` models)."""
     from interlace.graph.column_lineage import column_impact
 
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
     if name not in compiled.models:
         raise NotFoundException(detail=f"unknown model: {name}")
@@ -458,6 +517,7 @@ async def get_plan(
     """Preview a plan. ``select`` takes comma-separated selectors (same grammar as
     POST /apply's ``selectors``); ``forward_only`` previews history-inheriting plans
     — so what you preview is exactly what POST /apply will do."""
+    await reload_if_stale(state)
     env = environment or state.environment
     compiled: CompiledProject = state.compiled
     selectors = [part.strip() for part in select.split(",") if part.strip()] if select else []
@@ -500,6 +560,7 @@ async def get_plan(
 
 @get("/environments")
 async def get_environments(state: State) -> list[EnvironmentInfo]:
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
     out: list[EnvironmentInfo] = []
     promoted_ats = await state.store.environment_promoted_at()
@@ -555,10 +616,16 @@ async def rollback_environment_endpoint(name: FromPath[str], state: State, data:
 
 
 @get("/runs")
-async def get_runs(state: State) -> list[RunInfo]:
+async def get_runs(state: State, limit: FromQuery[int | None] = None) -> list[RunInfo]:
     runs: list[RunInfo] = []
     for run in await state.store.list_runs():
         partition = [str(run["partition_start"]), str(run["partition_end"])] if run["partition_start"] else None
+        started, finished = run.get("started_at"), run.get("finished_at")
+        duration = None
+        if started and finished:  # ledger timestamps are naive ISO; the span is what we want
+            from datetime import datetime
+
+            duration = (datetime.fromisoformat(finished) - datetime.fromisoformat(started)).total_seconds()
         runs.append(
             RunInfo(
                 id=run["id"],
@@ -571,9 +638,11 @@ async def get_runs(state: State) -> list[RunInfo]:
                 partition=partition,
                 restate=run["restate"],
                 idempotency_key=run["idempotency_key"],
+                environment=run.get("environment"),
+                duration=duration,
             )
         )
-    return runs
+    return runs[:limit] if limit else runs  # list_runs is newest-first
 
 
 @get("/runs/{run_id:int}")
@@ -581,10 +650,12 @@ async def get_run(run_id: FromPath[int], state: State) -> RunDetail:
     run = await state.store.get_run(run_id)
     if run is None:
         raise NotFoundException(detail=f"unknown run: {run_id}")
-    # lifecycle events are keyed by run id (worker) and idempotency key (enqueue)
-    events = await state.store.events_for_entity(str(run_id))
+    # lifecycle events are keyed by run id (worker) and idempotency key (enqueue); the
+    # per-model events are keyed by payload.run (their entity is the model name)
+    events = await state.store.events_for_entity(str(run_id)) + await state.store.events_for_run(run_id)
     if run["idempotency_key"]:
-        events = sorted(events + await state.store.events_for_entity(run["idempotency_key"]), key=lambda e: e["seq"])
+        events += await state.store.events_for_entity(run["idempotency_key"])
+    events = sorted({event["seq"]: event for event in events}.values(), key=lambda event: event["seq"])
     partition = [str(run["partition_start"]), str(run["partition_end"])] if run["partition_start"] else None
     return RunDetail(
         id=run["id"],
@@ -603,6 +674,7 @@ async def get_run(run_id: FromPath[int], state: State) -> RunDetail:
 
 @post("/runs", opt={"scope": "write"})
 async def create_run(data: CreateRun, state: State) -> CreateRunResult:
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
     env = data.environment or state.environment
     try:
@@ -632,6 +704,7 @@ async def create_run(data: CreateRun, state: State) -> CreateRunResult:
     enqueued = await state.store.enqueue_run(key, models, partition, 0, restate=data.restate)
     if enqueued:
         await state.store.append_event("run.enqueued", entity=key, payload={"models": models})
+        state.drain_wanted.set()  # wake the scheduler now, don't wait out the tick interval
     return CreateRunResult(enqueued=1 if enqueued else 0, models=models)
 
 
@@ -648,6 +721,7 @@ async def cancel_run(run_id: FromPath[int], state: State) -> dict:
 
 @post("/apply", opt={"scope": "write"})
 async def post_apply(data: ApplyRequest, state: State) -> ApplyResponse:
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
     env = data.environment or state.environment
     try:
@@ -713,12 +787,28 @@ async def post_apply(data: ApplyRequest, state: State) -> ApplyResponse:
             for name, c in result.rows.items()
         },
         timings={name: round(seconds, 3) for name, seconds in result.timings.items()},
+        gated=result.gated,
+        checks=[
+            CheckOutcomeInfo(
+                model=outcome.model,
+                name=outcome.name,
+                check_type=outcome.type,
+                severity=outcome.severity,
+                status=outcome.status,
+                failures=outcome.failures,
+                message=outcome.message,
+            )
+            for outcome in result.checks
+        ],
     )
 
 
 @get("/checks")
-async def get_checks(state: State, model: FromQuery[str | None] = None) -> list[CheckResultInfo]:
-    return [CheckResultInfo(**row) for row in await state.store.list_check_results(model)]
+async def get_checks(
+    state: State, model: FromQuery[str | None] = None, limit: FromQuery[int | None] = None
+) -> list[CheckResultInfo]:
+    rows = await state.store.list_check_results(model)
+    return [CheckResultInfo(**row) for row in (rows[:limit] if limit else rows)]
 
 
 async def _enqueue_stream_consumers(state: State, stream: StreamDef) -> None:
@@ -734,6 +824,7 @@ async def _enqueue_stream_consumers(state: State, stream: StreamDef) -> None:
     key = f"stream:{stream.name}:{watermark}"
     if await state.store.enqueue_run(key, sorted(consumers), None, 0):
         await state.store.append_event("run.enqueued", entity=key, payload={"models": sorted(consumers)})
+        state.drain_wanted.set()  # wake the scheduler now, don't wait out the tick interval
 
 
 def _stream_or_404(state: State, name: str) -> StreamDef:
@@ -938,6 +1029,7 @@ async def get_schedules(state: State) -> list[ScheduleInfo]:
 
     from cronsim import CronSim
 
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
     infos: list[ScheduleInfo] = []
     for name in sorted(compiled.models):
@@ -1009,12 +1101,13 @@ async def _described_columns(state: State, name: str, promoted: dict[str, str],
 
 
 @get("/lineage")
-async def get_lineage(state: State) -> LineageResponse:
+async def get_lineage(state: State, environment: FromQuery[str | None] = None) -> LineageResponse:
     """The whole graph in one payload: nodes (with warehouse-described column
     types), table edges, column lineage, and stream sources — the UI renders
-    and traces without a request per node."""
+    and traces without a request per node. ``?environment=`` inspects a sandbox."""
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
-    promoted = await state.store.get_environment(state.environment)
+    promoted = await state.store.get_environment(environment or state.environment)
     snapshots = await state.store.get_snapshots(promoted.items())
 
     order = compiled.graph.topological_sort()
@@ -1089,6 +1182,7 @@ async def post_checks_run(state: State, data: RunChecksRequest | None = None) ->
     from interlace.checks.runner import run_checks
 
     request = data or RunChecksRequest()
+    await reload_if_stale(state)
     compiled: CompiledProject = state.compiled
     env = request.environment or state.environment
     promoted = await state.store.get_environment(env)
@@ -1319,11 +1413,17 @@ def create_app(
         app.state.engines = engines
         app.state.environment = environment
         app.state.root = project.root
+        app.state.model_paths = project.config.model_paths  # for the on-demand recompile staleness probe
+        app.state.reload_lock = asyncio.Lock()  # serialise recompiles; recompile at most once per change
+        app.state.source_mtime = _source_mtime(project.root, project.config.model_paths)
         app.state.parallelism = project.config.parallelism
         app.state.engine_configs = project.config.engine_configs()
         app.state.default_engine = project.config.default_engine
         app.state.describe_cache = {}  # (model, fingerprint) -> {column: type}, filled by /lineage
         app.state.apply_lock = asyncio.Lock()  # serialise applies against the single warehouse connection
+        # Wake the scheduler's drain the instant a run is enqueued, instead of waiting
+        # out the tick interval — an enqueue from the UI/API/stream picks up promptly.
+        app.state.drain_wanted = asyncio.Event()
         app.state.streams = streams
         app.state.stream_log = stream_log
         app.state.flush_targets = flush_targets  # streams + their quarantine shadows
@@ -1411,11 +1511,15 @@ def create_app(
             app.state.flush_wanted.set()  # catch up anything durable but unflushed at last shutdown
 
         async def scheduler_loop() -> None:
-            trigger_engine = TriggerEngine(build_triggers(compiled), store)
             next_trim = asyncio.get_running_loop().time()  # first tick trims; then every 6h
             while True:
+                # cleared before the pass so an enqueue landing mid-drain re-arms the
+                # event and earns another prompt pass rather than being lost
+                app.state.drain_wanted.clear()
                 try:
-                    await trigger_engine.tick(datetime.now())
+                    await reload_if_stale(app.state)  # scheduled/queued builds see on-disk edits too
+                    compiled = app.state.compiled  # live: reload may have swapped it
+                    await TriggerEngine(build_triggers(compiled), store).tick(datetime.now())
                     if asyncio.get_running_loop().time() >= next_trim:
                         # event_log / check_results / terminal queue rows grow with
                         # every apply and flush; nothing else reclaims them
@@ -1435,7 +1539,9 @@ def create_app(
                         await sweep_streams(streams.values(), stream_log, engine)  # apply retention
                 except Exception:
                     logger.exception("scheduler tick failed; retrying next interval")
-                await asyncio.sleep(scheduler_interval)
+                # wake early the instant a run is enqueued; otherwise tick on the interval
+                with contextlib.suppress(asyncio.TimeoutError):
+                    await asyncio.wait_for(app.state.drain_wanted.wait(), timeout=scheduler_interval)
 
         async def shutdown_watch() -> None:
             """End every open SSE stream the moment uvicorn begins shutting down.

{interlaced-2.1.0 → interlaced-2.2.0}/src/interlace/service/ui/app.css

@@ -74,6 +74,7 @@ input, textarea, select { font: inherit; color: inherit; }
 }
 .brand { display: flex; align-items: center; gap: 8px; }
 .wordmark { font-weight: 600; letter-spacing: 0.02em; }
+.wordmark .wordmark-tld { color: var(--tx-faint); font-weight: 500; }  /* muted ".sh" */
 .grow { flex: 1; }
 
 .env-chip {
@@ -181,6 +182,26 @@ table.t { width: 100%; border-collapse: collapse; font-size: 12px; }
 .t .dim { color: var(--tx-dim); }
 .t .faint { color: var(--tx-faint); }
 
+/* compact variant (run detail): the CLI's small font + rule-under-header, but no
+   per-row separators — the rows read as one tight block, not a striped grid */
+.t.compact { font-size: 11.5px; }
+.t.compact th { padding: 3px 9px; }
+.t.compact td { padding: 2.5px 9px; border-bottom: 0; }
+.t.compact .tl-mark { display: inline-block; width: 13px; text-align: center; }
+
+/* run detail: a dim header line (env · duration · models · window · attempt) above
+   the build table, all riding the expand-row's inset background. .dim/.faint are
+   otherwise scoped to .t, so re-declare them for the header spans living outside it */
+.run-detail { display: flex; flex-direction: column; gap: 8px; }
+.run-meta { font-size: 11.5px; }
+.run-detail .dim { color: var(--tx-dim); }
+.run-detail .faint { color: var(--tx-faint); }
+
+/* models cell: "13 models · a, b, c…" — count stays, names shrink to an ellipsis */
+.run-models { display: inline-flex; align-items: baseline; max-width: 460px; vertical-align: top; }
+.rm-count { flex: 0 0 auto; white-space: nowrap; }
+.rm-names { flex: 0 1 auto; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; color: var(--tx-dim); }
+
 .empty { padding: 26px; text-align: center; color: var(--tx-dim); }
 .empty .hint { font-size: 11px; color: var(--tx-faint); margin-top: 4px; }
 
@@ -324,6 +345,24 @@ pre.sql { background: var(--ink-0); border: 1px solid var(--line-soft); border-r
 .feed-row .ty { color: var(--tx-dim); width: 140px; flex-shrink: 0; }
 .feed-row .en { color: var(--tx); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 
+/* ---- activity: build episodes (apply / run) + model timelines ---------------- */
+.episode { border-bottom: 1px solid var(--line-soft); }
+.episode:last-child { border-bottom: 0; }
+.episode-head { display: flex; align-items: center; gap: 8px; width: 100%; text-align: left; padding: 5px 12px; font-size: 11.5px; }
+.episode-head:hover { background: var(--ink-2); }
+.episode-head .spread { flex: 1; }
+.ep-kind { color: var(--tx); font-weight: 500; }
+.ep-target { color: var(--violet); }
+.ep-meta { color: var(--tx-dim); font-size: 11px; }
+.episode-head .ts { color: var(--tx-faint); }
+.timeline { display: flex; flex-direction: column; gap: 2px; padding: 4px 12px 8px 30px; }
+.tl-step { display: flex; align-items: baseline; gap: 8px; font-size: 11.5px; }
+.tl-mark { width: 13px; text-align: center; flex-shrink: 0; }
+.tl-mark.running::before { content: "◌"; color: var(--amber); display: inline-block; animation: spin 0.9s linear infinite; }
+.tl-name { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.tl-dur { color: var(--tx-faint); font-size: 11px; }
+.tl-empty { padding: 8px 12px; color: var(--tx-faint); font-size: 11.5px; }
+
 /* ---- query console --------------------------------------------------------- */
 .q-layout { display: grid; grid-template-columns: 1fr 240px; gap: 12px; align-items: start; }
 .q-layout .card { margin-top: 0; }

interlaced-2.2.0/src/interlace/service/ui/favicon.svg

@@ -0,0 +1,28 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" fill="none" role="img" aria-label="Interlace">
+  <title>Interlace</title>
+  <!-- Two loops in plain weave (matches interlace.sh). Each loop is knocked out by the
+       other's own stroke at width 13 against the 6 drawn, so the clearance follows the
+       curve; the clip paths confine each cut to one crossing quadrant. -->
+  <style>
+    .a { stroke: #6D28D9; } .b { stroke: #8B5CF6; }
+    @media (prefers-color-scheme: dark) { .a { stroke: #8B5CF6; } .b { stroke: #C4B5FD; } }
+  </style>
+  <defs>
+    <mask id="dh" maskUnits="userSpaceOnUse" x="0" y="0" width="64" height="64">
+      <rect width="64" height="64" fill="#fff"/>
+      <g clip-path="url(#dtl)"><rect x="20" y="6" width="24" height="52" rx="12" fill="none" stroke="#000" stroke-width="13"/></g>
+      <g clip-path="url(#dbr)"><rect x="20" y="6" width="24" height="52" rx="12" fill="none" stroke="#000" stroke-width="13"/></g>
+    </mask>
+    <mask id="dv" maskUnits="userSpaceOnUse" x="0" y="0" width="64" height="64">
+      <rect width="64" height="64" fill="#fff"/>
+      <g clip-path="url(#dtr)"><rect x="6" y="20" width="52" height="24" rx="12" fill="none" stroke="#000" stroke-width="13"/></g>
+      <g clip-path="url(#dbl)"><rect x="6" y="20" width="52" height="24" rx="12" fill="none" stroke="#000" stroke-width="13"/></g>
+    </mask>
+    <clipPath id="dtl"><rect x="10" y="10" width="18" height="18"/></clipPath>
+    <clipPath id="dbr"><rect x="36" y="36" width="18" height="18"/></clipPath>
+    <clipPath id="dtr"><rect x="36" y="10" width="18" height="18"/></clipPath>
+    <clipPath id="dbl"><rect x="10" y="36" width="18" height="18"/></clipPath>
+  </defs>
+  <rect x="6" y="20" width="52" height="24" rx="12" fill="none" class="a" stroke="#8B5CF6" stroke-width="6" mask="url(#dh)"/>
+  <rect x="20" y="6" width="24" height="52" rx="12" fill="none" class="b" stroke="#C4B5FD" stroke-width="6" mask="url(#dv)"/>
+</svg>

{interlaced-2.1.0 → interlaced-2.2.0}/src/interlace/service/ui/index.html

@@ -3,7 +3,7 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>interlace</title>
+<title>interlace.sh</title>
 <meta name="description" content="interlace control plane — a Python/SQL-first data platform: transformation, orchestration, and durable streaming in one daemon.">
 
 <meta name="theme-color" content="#0B0E16">
@@ -14,8 +14,8 @@
 <div class="shell">
   <header class="topbar">
     <a class="brand" href="#/overview" title="Overview">
-      <svg class="mark" width="20" height="20" viewBox="0 0 70 70" fill="none" aria-hidden="true"><defs><linearGradient id="ilw" x1="-0.2" y1="19.8" x2="57.7" y2="35.2" gradientUnits="userSpaceOnUse"><stop stop-color="#6D3AE8"/><stop offset="1" stop-color="#8B5CF6"/></linearGradient></defs><path d="M68.2607 1.61092C68.4788 1.96371 68.5754 2.27791 68.6696 2.67864C74.1598 25.0448 62.7309 43.5941 33.014 47.4454C32.5623 45.8885 31.8379 41.9877 31.9809 40.2956C41.5659 39.8226 67.7537 34.138 64.0203 6.52842C64.0053 6.45221 63.9902 6.376 63.9747 6.29748C63.826 6.00794 63.6673 5.96618 63.3632 5.85253C51.866 4.88111 45.3557 8.441 41.6989 12.112C39.642 10.9648 37.4673 9.69931 35.1631 9.03685C44.0953 0.751236 56.3592 -1.84409 67.5497 1.28114C68.0858 1.42257 68.0858 1.42257 68.2607 1.61092Z" fill="url(#ilw)"/><path d="M50.9691 69.9985C50.5557 70.0117 50.2364 69.9386 49.8436 69.8201C27.8037 63.4102 17.516 44.1994 29.0521 16.4382C30.6211 16.824 34.3484 18.1446 35.7366 19.1149C31.3521 27.6846 23.1622 53.2942 48.8471 63.8532C48.9204 63.8782 48.9936 63.9033 49.0691 63.929C49.3932 63.9445 49.5086 63.8275 49.7587 63.6199C56.3453 54.1101 56.5294 46.6702 55.191 41.6555C57.2091 40.4408 59.3881 39.1829 61.1118 37.5109C63.7935 49.4192 59.9004 61.379 51.6091 69.5452C51.219 69.9406 51.219 69.9406 50.9691 69.9985Z" fill="url(#ilw)"/><path d="M0.0496005 20.4961C0.244872 20.1301 0.467638 19.889 0.766215 19.6067C17.3159 3.65055 39.0324 4.31202 57.2133 28.2219C56.096 29.3931 53.0931 31.9732 51.5619 32.695C46.3613 24.5983 28.3634 4.67332 6.41198 21.7239C6.35376 21.7751 6.29554 21.8263 6.23555 21.879C6.06014 22.1531 6.10344 22.3119 6.15748 22.6331C11.068 33.1143 17.3942 36.9943 22.3895 38.338C22.4283 40.6999 22.4239 43.2233 23.0046 45.5578C11.3907 41.935 3.01978 32.5706 0.120605 21.2792C-0.0254669 20.7423 -0.0254668 20.7423 0.0496005 20.4961Z" fill="url(#ilw)"/></svg>
-      <span class="wordmark">interlace</span>
+      <svg class="mark" width="22" height="22" viewBox="0 0 64 64" fill="none" aria-hidden="true"><defs><mask id="ilh" maskUnits="userSpaceOnUse" x="0" y="0" width="64" height="64"><rect width="64" height="64" fill="#fff"/><g clip-path="url(#iltl)"><rect x="20" y="6" width="24" height="52" rx="12" fill="none" stroke="#000" stroke-width="13"/></g><g clip-path="url(#ilbr)"><rect x="20" y="6" width="24" height="52" rx="12" fill="none" stroke="#000" stroke-width="13"/></g></mask><mask id="ilv" maskUnits="userSpaceOnUse" x="0" y="0" width="64" height="64"><rect width="64" height="64" fill="#fff"/><g clip-path="url(#iltr)"><rect x="6" y="20" width="52" height="24" rx="12" fill="none" stroke="#000" stroke-width="13"/></g><g clip-path="url(#ilbl)"><rect x="6" y="20" width="52" height="24" rx="12" fill="none" stroke="#000" stroke-width="13"/></g></mask><clipPath id="iltl"><rect x="10" y="10" width="18" height="18"/></clipPath><clipPath id="ilbr"><rect x="36" y="36" width="18" height="18"/></clipPath><clipPath id="iltr"><rect x="36" y="10" width="18" height="18"/></clipPath><clipPath id="ilbl"><rect x="10" y="36" width="18" height="18"/></clipPath></defs><rect x="6" y="20" width="52" height="24" rx="12" fill="none" stroke="#8B5CF6" stroke-width="6" mask="url(#ilh)"/><rect x="20" y="6" width="24" height="52" rx="12" fill="none" stroke="#C4B5FD" stroke-width="6" mask="url(#ilv)"/></svg>
+      <span class="wordmark">interlace<span class="wordmark-tld">.sh</span></span>
     </a>
     <button class="env-chip" id="envChip" title="Target environment (prod = the unprefixed namespace)">
       <span class="env-key">env</span><span class="env-val" id="envName">prod</span>