taskclf 0.2.3__tar.gz → 0.3.1__tar.gz

{taskclf-0.2.3 → taskclf-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: taskclf
-Version: 0.2.3
+Version: 0.3.1
 Summary: Local-first task classifier that infers your work type from computer activity signals
 Author: fruitiecutiepie
 Author-email: fruitiecutiepie <104437268+fruitiecutiepie@users.noreply.github.com>
@@ -26,7 +26,6 @@ Requires-Dist: uvicorn[standard]>=0.34.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: pystray>=0.19.5
 Requires-Dist: pillow>=11.0.0
-Requires-Dist: plyer>=2.1.0
 Requires-Python: >=3.14
 Project-URL: Homepage, https://github.com/fruitiecutiepie/taskclf
 Project-URL: Documentation, https://fruitiecutiepie.github.io/taskclf

{taskclf-0.2.3 → taskclf-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taskclf"
-version = "0.2.3"
+version = "0.3.1"
 description = "Local-first task classifier that infers your work type from computer activity signals"
 readme = "README.md"
 license = {text = "MIT"}
@@ -32,7 +32,6 @@ dependencies = [
     "pyyaml>=6.0",
     "pystray>=0.19.5",
     "Pillow>=11.0.0",
-    "plyer>=2.1.0",
 ]
 
 [project.urls]

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/adapters/activitywatch/client.py

@@ -35,10 +35,12 @@ _INPUT_TYPE = "os.hid.input"
 
 
 def _parse_timestamp(raw: str) -> datetime:
-    """Parse an ISO-8601 timestamp from AW into a naive-UTC datetime."""
+    """Parse an ISO-8601 timestamp from AW into a timezone-aware UTC datetime."""
     ts = datetime.fromisoformat(raw)
     if ts.tzinfo is not None:
-        ts = ts.astimezone(timezone.utc).replace(tzinfo=None)
+        ts = ts.astimezone(timezone.utc)
+    else:
+        ts = ts.replace(tzinfo=timezone.utc)
     return ts
 
 

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/cli/main.py

@@ -1,6 +1,7 @@
 """Typer CLI entrypoint and command definitions for taskclf."""
 
 import datetime as dt
+import logging
 from importlib.metadata import version as _pkg_version
 from pathlib import Path
 
@@ -48,8 +49,16 @@ def main(
         False, "--version", "-v", callback=_version_callback, is_eager=True,
         help="Show version and exit.",
     ),
+    verbose: bool = typer.Option(
+        False, "--verbose", help="Enable DEBUG logging with file/line info.",
+    ),
 ) -> None:
     """Local-first task classifier CLI."""
+    level = logging.DEBUG if verbose else logging.WARNING
+    logging.basicConfig(
+        level=level,
+        format="%(levelname)s %(name)s %(pathname)s:%(lineno)d — %(message)s",
+    )
 
 
 # -- ingest -------------------------------------------------------------------
@@ -195,6 +204,7 @@ def labels_add_block_cmd(
 
     start_ts = dt.datetime.fromisoformat(start)
     end_ts = dt.datetime.fromisoformat(end)
+    effective_confidence = confidence if confidence is not None else 1.0
 
     span = LabelSpan(
         start_ts=start_ts,
@@ -202,7 +212,7 @@ def labels_add_block_cmd(
         label=label,
         provenance="manual",
         user_id=user_id,
-        confidence=confidence,
+        confidence=effective_confidence,
     )
 
     features_dfs: list[pd.DataFrame] = []
@@ -283,12 +293,13 @@ def labels_label_now_cmd(
     from rich.table import Table
 
     from taskclf.core.store import read_parquet
+    from taskclf.core.time import to_naive_utc
     from taskclf.core.types import LabelSpan
     from taskclf.labels.store import append_label_span, generate_label_summary
 
     console = Console()
 
-    end_ts = dt.datetime.now(dt.timezone.utc).replace(tzinfo=None)
+    end_ts = dt.datetime.now(dt.timezone.utc)
     start_ts = end_ts - dt.timedelta(minutes=minutes)
 
     console.print(
@@ -319,11 +330,15 @@ def labels_label_now_cmd(
     except Exception as exc:
         console.print(f"[dim]ActivityWatch not reachable ({exc}); skipping live summary.[/dim]")
 
+    # Normalize to naive UTC for feature/label pipeline compatibility
+    start_ts_naive = to_naive_utc(start_ts)
+    end_ts_naive = to_naive_utc(end_ts)
+
     # On-disk feature summary (best-effort)
     features_dfs: list[pd.DataFrame] = []
     data_path = Path(data_dir)
-    current_date = start_ts.date()
-    while current_date <= end_ts.date():
+    current_date = start_ts_naive.date()
+    while current_date <= end_ts_naive.date():
         fp = data_path / f"features_v1/date={current_date.isoformat()}" / "features.parquet"
         if fp.exists():
             features_dfs.append(read_parquet(fp))
@@ -331,7 +346,7 @@ def labels_label_now_cmd(
 
     if features_dfs:
         feat_df = pd.concat(features_dfs, ignore_index=True)
-        summary = generate_label_summary(feat_df, start_ts, end_ts)
+        summary = generate_label_summary(feat_df, start_ts_naive, end_ts_naive)
         if summary["total_buckets"] > 0:
             table = Table(title="Feature Summary")
             table.add_column("Metric", style="bold")
@@ -346,13 +361,14 @@ def labels_label_now_cmd(
                 table.add_row(f"App: {app_info['app_id']}", f"{app_info['buckets']} buckets")
             console.print(table)
 
+    effective_confidence = confidence if confidence is not None else 1.0
     span = LabelSpan(
-        start_ts=start_ts,
-        end_ts=end_ts,
+        start_ts=start_ts_naive,
+        end_ts=end_ts_naive,
         label=label,
         provenance="manual",
         user_id=user_id,
-        confidence=confidence,
+        confidence=effective_confidence,
     )
 
     labels_path = Path(data_dir) / "labels_v1" / "labels.parquet"
@@ -364,7 +380,7 @@ def labels_label_now_cmd(
 
     typer.echo(
         f"Labeled: {label} [{start_ts:%H:%M} → {end_ts:%H:%M} UTC] "
-        f"user={user_id} confidence={confidence}"
+        f"user={user_id} confidence={effective_confidence}"
     )
 
 
@@ -470,6 +486,26 @@ train_app = typer.Typer()
 app.add_typer(train_app, name="train")
 
 
+def _load_real_labels(
+    data_dir: str,
+    start: dt.date,
+    end: dt.date,
+) -> list:
+    """Load label spans from disk, filtered to the given date range."""
+    from taskclf.labels.store import read_label_spans
+
+    labels_path = Path(data_dir) / "labels_v1" / "labels.parquet"
+    if not labels_path.exists():
+        return []
+
+    all_spans = read_label_spans(labels_path)
+    start_dt = dt.datetime(start.year, start.month, start.day, tzinfo=dt.timezone.utc)
+    end_dt = dt.datetime(
+        end.year, end.month, end.day, 23, 59, 59, tzinfo=dt.timezone.utc
+    )
+    return [s for s in all_spans if s.end_ts >= start_dt and s.start_ts <= end_dt]
+
+
 @train_app.command("build-dataset")
 def train_build_dataset_cmd(
     date_from: str = typer.Option(..., "--from", help="Start date (YYYY-MM-DD)"),
@@ -496,11 +532,18 @@ def train_build_dataset_cmd(
     all_labels: list = []
     current = start
 
+    if not synthetic:
+        all_labels = _load_real_labels(data_dir, start, end)
+        typer.echo(f"Loaded {len(all_labels)} label spans from disk")
+        if not all_labels:
+            typer.echo("WARNING: no label spans found — labeled dataset will be empty", err=True)
+
     while current <= end:
         if synthetic:
             rows = generate_dummy_features(current, n_rows=60)
             df = pd.DataFrame([r.model_dump() for r in rows])
             labels = generate_dummy_labels(current, n_rows=60)
+            all_labels.extend(labels)
         else:
             parquet_path = Path(data_dir) / f"features_v1/date={current.isoformat()}" / "features.parquet"
             if not parquet_path.exists():
@@ -508,10 +551,8 @@ def train_build_dataset_cmd(
                 current += dt.timedelta(days=1)
                 continue
             df = read_parquet(parquet_path)
-            labels = generate_dummy_labels(current, n_rows=len(df))
 
         all_features.append(df)
-        all_labels.extend(labels)
         current += dt.timedelta(days=1)
 
     if not all_features:
@@ -562,14 +603,21 @@ def train_lgbm_cmd(
     end = dt.date.fromisoformat(date_to)
 
     all_features: list[pd.DataFrame] = []
-    all_labels = []
+    all_labels: list = []
     current = start
 
+    if not synthetic:
+        all_labels = _load_real_labels(data_dir, start, end)
+        typer.echo(f"Loaded {len(all_labels)} label spans from disk")
+        if not all_labels:
+            typer.echo("WARNING: no label spans found — labeled dataset will be empty", err=True)
+
     while current <= end:
         if synthetic:
             rows = generate_dummy_features(current, n_rows=60)
             df = pd.DataFrame([r.model_dump() for r in rows])
             labels = generate_dummy_labels(current, n_rows=60)
+            all_labels.extend(labels)
         else:
             parquet_path = Path(data_dir) / f"features_v1/date={current.isoformat()}" / "features.parquet"
             if not parquet_path.exists():
@@ -577,10 +625,8 @@ def train_lgbm_cmd(
                 current += dt.timedelta(days=1)
                 continue
             df = read_parquet(parquet_path)
-            labels = generate_dummy_labels(current, n_rows=len(df))
 
         all_features.append(df)
-        all_labels.extend(labels)
         current += dt.timedelta(days=1)
 
     if not all_features:
@@ -671,11 +717,19 @@ def train_evaluate_cmd(
     all_features: list[pd.DataFrame] = []
     all_labels: list = []
     current = start
+
+    if not synthetic:
+        all_labels = _load_real_labels(data_dir, start, end)
+        typer.echo(f"Loaded {len(all_labels)} label spans from disk")
+        if not all_labels:
+            typer.echo("WARNING: no label spans found — labeled dataset will be empty", err=True)
+
     while current <= end:
         if synthetic:
             rows = generate_dummy_features(current, n_rows=60)
             df = pd.DataFrame([r.model_dump() for r in rows])
             labels = generate_dummy_labels(current, n_rows=60)
+            all_labels.extend(labels)
         else:
             parquet_path = Path(data_dir) / f"features_v1/date={current.isoformat()}" / "features.parquet"
             if not parquet_path.exists():
@@ -683,9 +737,7 @@ def train_evaluate_cmd(
                 current += dt.timedelta(days=1)
                 continue
             df = read_parquet(parquet_path)
-            labels = generate_dummy_labels(current, n_rows=len(df))
         all_features.append(df)
-        all_labels.extend(labels)
         current += dt.timedelta(days=1)
 
     if not all_features:
@@ -817,11 +869,19 @@ def train_tune_reject_cmd(
     all_features: list[pd.DataFrame] = []
     all_labels: list = []
     current = start
+
+    if not synthetic:
+        all_labels = _load_real_labels(data_dir, start, end)
+        typer.echo(f"Loaded {len(all_labels)} label spans from disk")
+        if not all_labels:
+            typer.echo("WARNING: no label spans found — labeled dataset will be empty", err=True)
+
     while current <= end:
         if synthetic:
             rows = generate_dummy_features(current, n_rows=60)
             df = pd.DataFrame([r.model_dump() for r in rows])
             labels = generate_dummy_labels(current, n_rows=60)
+            all_labels.extend(labels)
         else:
             parquet_path = Path(data_dir) / f"features_v1/date={current.isoformat()}" / "features.parquet"
             if not parquet_path.exists():
@@ -829,9 +889,7 @@ def train_tune_reject_cmd(
                 current += dt.timedelta(days=1)
                 continue
             df = read_parquet(parquet_path)
-            labels = generate_dummy_labels(current, n_rows=len(df))
         all_features.append(df)
-        all_labels.extend(labels)
         current += dt.timedelta(days=1)
 
     if not all_features:
@@ -846,7 +904,7 @@ def train_tune_reject_cmd(
         raise typer.Exit(code=1)
 
     splits = split_by_time(labeled_df)
-    val_df = splits["val"]
+    val_df = labeled_df.iloc[splits["val"]].reset_index(drop=True)
     if val_df.empty:
         typer.echo("Validation split is empty — using full dataset.", err=True)
         val_df = labeled_df
@@ -920,14 +978,19 @@ def train_calibrate_cmd(
     all_features: list[pd.DataFrame] = []
     all_labels: list = []
     current = start
+
+    if not synthetic:
+        all_labels = _load_real_labels(data_dir, start, end)
+        typer.echo(f"Loaded {len(all_labels)} label spans from disk")
+        if not all_labels:
+            typer.echo("WARNING: no label spans found — labeled dataset will be empty", err=True)
+
     while current <= end:
         if synthetic:
-            from taskclf.features.build import generate_dummy_features
-            from taskclf.labels.store import generate_dummy_labels
-
             rows = generate_dummy_features(current, n_rows=60)
             df = pd.DataFrame([r.model_dump() for r in rows])
             labels = generate_dummy_labels(current, n_rows=60)
+            all_labels.extend(labels)
         else:
             parquet_path = Path(data_dir) / f"features_v1/date={current.isoformat()}" / "features.parquet"
             if not parquet_path.exists():
@@ -935,10 +998,8 @@ def train_calibrate_cmd(
                 current += dt.timedelta(days=1)
                 continue
             df = read_parquet(parquet_path)
-            labels = generate_dummy_labels(current, n_rows=len(df))
 
         all_features.append(df)
-        all_labels.extend(labels)
         current += dt.timedelta(days=1)
 
     if not all_features:
@@ -1047,11 +1108,19 @@ def train_retrain_cmd(
     all_features: list[pd.DataFrame] = []
     all_labels: list = []
     current = start
+
+    if not synthetic:
+        all_labels = _load_real_labels(data_dir, start, end)
+        typer.echo(f"Loaded {len(all_labels)} label spans from disk")
+        if not all_labels:
+            typer.echo("WARNING: no label spans found — labeled dataset will be empty", err=True)
+
     while current <= end:
         if synthetic:
             rows = generate_dummy_features(current, n_rows=60)
             df = pd.DataFrame([r.model_dump() for r in rows])
             labels = generate_dummy_labels(current, n_rows=60)
+            all_labels.extend(labels)
         else:
             parquet_path = Path(data_dir) / f"features_v1/date={current.isoformat()}" / "features.parquet"
             if not parquet_path.exists():
@@ -1059,9 +1128,8 @@ def train_retrain_cmd(
                 current += dt.timedelta(days=1)
                 continue
             df = read_parquet(parquet_path)
-            labels = generate_dummy_labels(current, n_rows=len(df))
+
         all_features.append(df)
-        all_labels.extend(labels)
         current += dt.timedelta(days=1)
 
     if not all_features:
@@ -1743,11 +1811,19 @@ def infer_compare_cmd(
     all_features: list[pd.DataFrame] = []
     all_labels: list = []
     current = start
+
+    if not synthetic:
+        all_labels = _load_real_labels(data_dir, start, end)
+        typer.echo(f"Loaded {len(all_labels)} label spans from disk")
+        if not all_labels:
+            typer.echo("WARNING: no label spans found — labeled dataset will be empty", err=True)
+
     while current <= end:
         if synthetic:
             rows = generate_dummy_features(current, n_rows=60)
             df = pd.DataFrame([r.model_dump() for r in rows])
             labels = generate_dummy_labels(current, n_rows=60)
+            all_labels.extend(labels)
         else:
             parquet_path = Path(data_dir) / f"features_v1/date={current.isoformat()}" / "features.parquet"
             if not parquet_path.exists():
@@ -1755,9 +1831,7 @@ def infer_compare_cmd(
                 current += dt.timedelta(days=1)
                 continue
             df = read_parquet(parquet_path)
-            labels = generate_dummy_labels(current, n_rows=len(df))
         all_features.append(df)
-        all_labels.extend(labels)
         current += dt.timedelta(days=1)
 
     if not all_features:
@@ -1881,9 +1955,9 @@ def report_daily_cmd(
             if smoothed_labels is None:
                 smoothed_labels = raw_labels
         if "mapped_label" in pred_df.columns:
-            mapped_labels = list(pred_df["mapped_label"].dropna().values)
-            if len(mapped_labels) == 0:
-                mapped_labels = None
+            from taskclf.core.defaults import MIXED_UNKNOWN as _MU
+
+            mapped_labels = list(pred_df["mapped_label"].fillna(_MU).values)
 
     app_switch_counts: list[float | int | None] | None = None
     if features_dir is not None:
@@ -2185,6 +2259,9 @@ def tray_cmd(
 
     from taskclf.ui.tray import run_tray
 
+    if dev:
+        logging.getLogger("taskclf").setLevel(logging.DEBUG)
+
     tmp_dir: str | None = None
     if data_dir is not None:
         resolved_data_dir = data_dir
@@ -2244,6 +2321,9 @@ def ui_serve_cmd(
     from taskclf.ui.tray import ActivityMonitor, _LabelSuggester
     from taskclf.ui.window import WindowAPI, run_window
 
+    if dev:
+        logging.getLogger("taskclf").setLevel(logging.DEBUG)
+
     tmp_dir: str | None = None
     if data_dir is not None:
         resolved_data_dir = data_dir

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/core/config.py

@@ -63,8 +63,8 @@ class UserConfig:
         return {}
 
     def _ensure_user_id(self) -> None:
-        """Generate and persist a stable ``user_id`` if one does not exist."""
-        if "user_id" not in self._data:
+        """Generate and persist a stable ``user_id`` if one is missing or invalid."""
+        if not self._data.get("user_id"):
             self._data["user_id"] = str(uuid.uuid4())
             self._persist()
 

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/core/model_io.py

@@ -3,12 +3,15 @@
 from __future__ import annotations
 
 import json
+import logging
 import random
 import subprocess
 from datetime import UTC, date, datetime
 from pathlib import Path
 from typing import Any, Literal
 
+logger = logging.getLogger(__name__)
+
 import lightgbm as lgb
 import pandas as pd
 from pydantic import BaseModel, Field
@@ -49,6 +52,7 @@ def _current_git_commit() -> str:
         )
         return result.stdout.strip() if result.returncode == 0 else "unknown"
     except Exception:
+        logger.debug("Could not determine git commit", exc_info=True)
         return "unknown"
 
 
@@ -174,7 +178,7 @@ def load_model_bundle(
         cat_encoders = {}
         for col, classes in vocab.items():
             le = LabelEncoder()
-            le.classes_ = __import__("numpy").array(classes)
+            le.fit(classes)
             cat_encoders[col] = le
 
     return model, metadata, cat_encoders

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/core/telemetry.py

@@ -6,6 +6,7 @@ Stores only aggregate statistics -- never raw content.
 from __future__ import annotations
 
 import json
+import os
 import tempfile
 from datetime import datetime, timezone
 from pathlib import Path
@@ -182,12 +183,15 @@ class TelemetryStore:
         line = snapshot.model_dump_json() + "\n"
 
         path.parent.mkdir(parents=True, exist_ok=True)
-        tmp = Path(tempfile.mktemp(dir=self._dir, suffix=".tmp"))
+        fd, tmp_str = tempfile.mkstemp(dir=self._dir, suffix=".tmp")
+        tmp = Path(tmp_str)
         try:
             existing = path.read_text() if path.exists() else ""
-            tmp.write_text(existing + line)
+            os.write(fd, (existing + line).encode())
+            os.close(fd)
             tmp.replace(path)
         except BaseException:
+            os.close(fd)
             tmp.unlink(missing_ok=True)
             raise
         return path

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/core/time.py

@@ -13,22 +13,36 @@ from typing import Sequence
 from taskclf.core.defaults import DEFAULT_BUCKET_SECONDS
 
 
+def to_naive_utc(ts: datetime) -> datetime:
+    """Normalize a datetime to naive UTC.
+
+    Aware datetimes are converted to UTC then stripped of tzinfo.
+    Naive datetimes are returned as-is (assumed to already represent UTC).
+
+    This is the canonical conversion for timestamps entering the feature
+    pipeline or Parquet storage, where the naive-UTC convention is used.
+    """
+    if ts.tzinfo is not None:
+        return ts.astimezone(timezone.utc).replace(tzinfo=None)
+    return ts
+
+
 def align_to_bucket(
     ts: datetime,
     bucket_seconds: int = DEFAULT_BUCKET_SECONDS,
 ) -> datetime:
     """Floor *ts* to the nearest bucket boundary.
 
-    If *ts* is timezone-aware it is first converted to UTC; the returned
-    datetime is always a naive UTC value (consistent with how feature rows
-    store ``bucket_start_ts``).
+    If *ts* is timezone-aware it is first converted to UTC.  Naive
+    datetimes are assumed to represent UTC.  The returned datetime is
+    always a **timezone-aware** UTC value (``tzinfo=timezone.utc``).
 
     Args:
         ts: Timestamp to align.
         bucket_seconds: Bucket width in seconds (default 60).
 
     Returns:
-        A naive UTC datetime whose POSIX epoch is a multiple of
+        A timezone-aware UTC datetime whose POSIX epoch is a multiple of
         *bucket_seconds*.
     """
     if ts.tzinfo is not None:
@@ -36,7 +50,7 @@ def align_to_bucket(
 
     epoch = int(ts.replace(tzinfo=timezone.utc).timestamp())
     aligned_epoch = (epoch // bucket_seconds) * bucket_seconds
-    return datetime.fromtimestamp(aligned_epoch, tz=timezone.utc).replace(tzinfo=None)
+    return datetime.fromtimestamp(aligned_epoch, tz=timezone.utc)
 
 
 def generate_bucket_range(
@@ -54,7 +68,7 @@ def generate_bucket_range(
         bucket_seconds: Bucket width in seconds (default 60).
 
     Returns:
-        Sorted list of naive-UTC bucket-start datetimes.
+        Sorted list of timezone-aware UTC bucket-start datetimes.
     """
     cur = align_to_bucket(start, bucket_seconds)
     end_aligned = align_to_bucket(end, bucket_seconds)

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/core/types.py

@@ -2,11 +2,12 @@
 
 from __future__ import annotations
 
-from datetime import datetime
+import math
+from datetime import datetime, timezone
 from enum import StrEnum
 from typing import Final, Protocol, runtime_checkable
 
-from pydantic import BaseModel, Field, ValidationInfo, model_validator
+from pydantic import BaseModel, Field, ValidationInfo, field_validator, model_validator
 
 
 @runtime_checkable
@@ -186,6 +187,16 @@ class FeatureRow(BaseModel, frozen=True):
         description="Raw window title; only accepted when title_policy=RAW_WINDOW_TITLE_OPT_IN.",
     )
 
+    @field_validator("bucket_start_ts", "bucket_end_ts", mode="before")
+    @classmethod
+    def _ensure_aware_utc(cls, v: object) -> object:
+        """Tag naive datetimes as UTC; convert non-UTC aware datetimes."""
+        if isinstance(v, datetime):
+            if v.tzinfo is None:
+                return v.replace(tzinfo=timezone.utc)
+            return v.astimezone(timezone.utc)
+        return v
+
     @model_validator(mode="before")
     @classmethod
     def reject_prohibited_fields(cls, values: dict, info: ValidationInfo) -> dict:  # type: ignore[override]
@@ -228,6 +239,14 @@ class LabelSpan(BaseModel, frozen=True):
     confidence: float | None = Field(
         default=None, ge=0.0, le=1.0, description="Labeler confidence (0-1)."
     )
+
+    @field_validator("confidence", mode="before")
+    @classmethod
+    def _nan_confidence_to_none(cls, v: object) -> object:
+        if isinstance(v, float) and math.isnan(v):
+            return None
+        return v
+
     extend_forward: bool = Field(
         default=False,
         description="When true, this label extends forward until the next label is created.",

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/features/build.py

@@ -65,7 +65,7 @@ def generate_dummy_features(
     """
     rows: list[FeatureRow] = []
     day_of_week = date.weekday()
-    session_start = dt.datetime(date.year, date.month, date.day, 9, 0)
+    session_start = dt.datetime(date.year, date.month, date.day, 9, 0, tzinfo=dt.timezone.utc)
     sid = stable_hash(f"{user_id}:{session_start.isoformat()}")
 
     tracker = DynamicsTracker()
@@ -74,7 +74,7 @@ def generate_dummy_features(
     for i in range(n_rows):
         hour = 9 + (i * 8 // max(n_rows, 1))
         minute = (i * 7) % 60
-        ts = dt.datetime(date.year, date.month, date.day, hour, minute)
+        ts = dt.datetime(date.year, date.month, date.day, hour, minute, tzinfo=dt.timezone.utc)
         end_ts = ts + dt.timedelta(seconds=DEFAULT_BUCKET_SECONDS)
 
         app_id, is_browser, is_editor, is_terminal, app_category = _DUMMY_APPS[
@@ -307,7 +307,7 @@ def build_features_from_aw_events(
         rolling_5=DEFAULT_ROLLING_WINDOW_5,
         rolling_15=DEFAULT_ROLLING_WINDOW_15,
     )
-    title_counts: dict[str, int] = defaultdict(int)
+    session_title_counts: dict[dt.datetime, dict[str, int]] = defaultdict(lambda: defaultdict(int))
 
     rows: list[FeatureRow] = []
     for bucket_ts in sorted_buckets:
@@ -347,7 +347,7 @@ def build_features_from_aw_events(
 
         # Title clustering (item 39)
         title_hash = dominant_ev.window_title_hash
-        title_counts[title_hash] += 1
+        session_title_counts[cur_session][title_hash] += 1
         w_title_bucket = title_hash_bucket(title_hash, DEFAULT_TITLE_HASH_BUCKETS)
 
         # Domain classification (item 38)
@@ -396,7 +396,7 @@ def build_features_from_aw_events(
                 event_density=input_agg["event_density"],
                 domain_category=domain_cat,
                 window_title_bucket=w_title_bucket,
-                title_repeat_count_session=title_counts[title_hash],
+                title_repeat_count_session=session_title_counts[cur_session][title_hash],
                 keys_per_min_rolling_5=dyn["keys_per_min_rolling_5"],
                 keys_per_min_rolling_15=dyn["keys_per_min_rolling_15"],
                 mouse_distance_rolling_5=dyn["mouse_distance_rolling_5"],

{taskclf-0.2.3 → taskclf-0.3.1}/src/taskclf/features/text.py

@@ -7,6 +7,8 @@ privacy invariant (see ``AGENTS.md``).
 
 from __future__ import annotations
 
+import hashlib
+
 from taskclf.core.hashing import salted_hash
 
 
@@ -35,7 +37,7 @@ def title_hash_bucket(title_hash: str, n_buckets: int = 256) -> int:
     feature that tree-based or embedding models can consume directly.
 
     If *title_hash* is not valid hex (e.g. from test data), falls back
-    to Python's built-in ``hash()`` for deterministic bucketing.
+    to a SHA-256 digest for deterministic bucketing.
 
     Args:
         title_hash: Hex string produced by :func:`featurize_title`
@@ -53,4 +55,4 @@ def title_hash_bucket(title_hash: str, n_buckets: int = 256) -> int:
     try:
         return int(title_hash, 16) % n_buckets
     except ValueError:
-        return abs(hash(title_hash)) % n_buckets
+        return int.from_bytes(hashlib.sha256(title_hash.encode()).digest()[:8], "big") % n_buckets