cctally 1.6.3 → 1.7.1

package/bin/_lib_semver.py

@@ -0,0 +1,105 @@
+"""Pure SemVer primitives — parse, format, bump-compute, sort-key.
+
+Eager-imported from bin/cctally to back release-flow internals and the
+update-banner version-compare predicate. Zero I/O, zero module-level
+side effects; safe to import from any context (script, SourceFileLoader,
+compile+exec).
+
+Spec: docs/superpowers/specs/2026-05-13-bin-cctally-split-design.md
+"""
+from __future__ import annotations
+
+import re
+
+# Exported as a building block: bin/cctally's RELEASE_HEADER_RE and
+# _cctally_release's _FORMULA_VERSION_RE both reuse this numeric-component
+# pattern for SemVer matching.
+_SEMVER_NUM = r'(?:0|[1-9]\d*)'
+
+_SEMVER_RE = re.compile(
+    rf'^({_SEMVER_NUM})\.({_SEMVER_NUM})\.({_SEMVER_NUM})'
+    rf'(?:-([a-zA-Z][a-zA-Z0-9-]*)\.({_SEMVER_NUM}))?$'
+)
+
+
+def _release_parse_semver(s: str) -> tuple[int, int, int, str | None, int | None]:
+    """Parse SemVer; raises ValueError on malformed input."""
+    m = _SEMVER_RE.match(s)
+    if not m:
+        raise ValueError(f"invalid semver: {s!r}")
+    major, minor, patch, prerelease_id, prerelease_n = m.groups()
+    return (
+        int(major),
+        int(minor),
+        int(patch),
+        prerelease_id,
+        int(prerelease_n) if prerelease_n is not None else None,
+    )
+
+
+def _release_format_semver(
+    major: int, minor: int, patch: int,
+    prerelease_id: str | None = None, prerelease_n: int | None = None,
+) -> str:
+    base = f"{major}.{minor}.{patch}"
+    if prerelease_id is None:
+        return base
+    return f"{base}-{prerelease_id}.{prerelease_n}"
+
+
+def _release_compute_next_version(
+    current: str | None, kind: str, bump: str | None, prerelease_id: str,
+) -> str:
+    """Pure function. Implements bump rules from spec Section 4.4."""
+    if current is None:
+        # First-ever release. Treat as 0.0.0 base.
+        cur_maj, cur_min, cur_pat, cur_id, cur_n = 0, 0, 0, None, None
+    else:
+        cur_maj, cur_min, cur_pat, cur_id, cur_n = _release_parse_semver(current)
+    is_prerelease = cur_id is not None
+
+    if kind == "finalize":
+        if not is_prerelease:
+            raise ValueError("cannot finalize: current version is not a prerelease")
+        return _release_format_semver(cur_maj, cur_min, cur_pat)
+
+    if kind == "prerelease":
+        if is_prerelease:
+            if bump is not None:
+                raise ValueError("--bump invalid when current version is a prerelease; rc counter increments only")
+            return _release_format_semver(cur_maj, cur_min, cur_pat, cur_id, cur_n + 1)
+        if bump is None:
+            raise ValueError("--bump required for first prerelease from stable version")
+        # Apply bump kind to current stable, then attach -<id>.1
+        nxt = _release_compute_next_version(current or "0.0.0", bump, None, prerelease_id)
+        nxt_maj, nxt_min, nxt_pat, _, _ = _release_parse_semver(nxt)
+        return _release_format_semver(nxt_maj, nxt_min, nxt_pat, prerelease_id, 1)
+
+    if is_prerelease:
+        raise ValueError("current version is a prerelease; run 'cctally release finalize' first or use --bump in a prerelease bump")
+
+    if kind == "patch":
+        return _release_format_semver(cur_maj, cur_min, cur_pat + 1)
+    if kind == "minor":
+        return _release_format_semver(cur_maj, cur_min + 1, 0)
+    if kind == "major":
+        return _release_format_semver(cur_maj + 1, 0, 0)
+    raise ValueError(f"unknown bump kind: {kind!r}")
+
+
+def _release_semver_sort_key(
+    parsed: tuple[int, int, int, str | None, int | None],
+) -> tuple:
+    """Total-order sort key for `_release_parse_semver` output.
+
+    SemVer §11.4: a stable release has higher precedence than a pre-release
+    of the same MAJOR.MINOR.PATCH. Naive tuple comparison breaks because
+    Python rejects ``None < str`` at runtime. The key returned here makes
+    stable releases sort *after* their pre-releases by inverting the
+    "has-prerelease" axis: stable → ``(maj, min, pat, 1, "", 0)``,
+    pre-release → ``(maj, min, pat, 0, id, n)``.
+    """
+    maj, min_, pat, pre_id, pre_n = parsed
+    if pre_id is None:
+        return (maj, min_, pat, 1, "", 0)
+    return (maj, min_, pat, 0, pre_id, pre_n)

package/bin/_lib_share.py

@@ -80,6 +80,7 @@ class ColumnSpec:
     label: str
     align: str = "left"   # "left" | "right" | "center"
     emphasis: bool = False
+    kind: str | None = None   # "project" | "model" | None — privacy chokepoint signal
 
 
 @dataclass(frozen=True)
@@ -358,7 +359,8 @@ def svg_rect(x: float, y: float, w: float, h: float, *,
 
 def svg_text(x: float, y: float, text: str, *,
              font_size: float, fill: str,
-             anchor: str = "start", weight: str = "normal") -> str:
+             anchor: str = "start", weight: str = "normal",
+             font_family: str | None = None) -> str:
     attrs = {
         "x": x,
         "y": y,
@@ -368,6 +370,8 @@ def svg_text(x: float, y: float, text: str, *,
     }
     if weight and weight != "normal":
         attrs["font-weight"] = weight
+    if font_family:
+        attrs["font-family"] = font_family
     return f'<text {_serialize_attrs(attrs)}>{_xml_escape(text)}</text>'
 
 
@@ -769,6 +773,22 @@ def _collect_project_costs(snap: ShareSnapshot) -> dict[str, float]:
             if p.project_label and p.project_label not in costs:
                 costs[p.project_label] = p.y_value
 
+    # project-typed columns (cross-tab Detail templates, issue #33). Sum the
+    # MoneyCell values for each kind='project' column across all rows; the
+    # column.label is the original project path (anon happens AFTER _collect).
+    # No current panel mixes ProjectCell rows AND project-typed columns — if a
+    # future template does, the `+=` here will double-count that project's
+    # total. Refactor to a (path, source) keyed accumulator if/when that lands.
+    for col in snap.columns:
+        if col.kind != "project":
+            continue
+        col_total = 0.0
+        for row in snap.rows:
+            cell = row.cells.get(col.key)
+            if isinstance(cell, MoneyCell):
+                col_total += cell.usd
+        costs[col.label] = costs.get(col.label, 0.0) + col_total
+
     return costs
 
 
@@ -867,6 +887,21 @@ def _apply_anon_mapping(
                 cap=snap.chart.cap,
             )
 
+    # Rewrite project-typed column headers (cross-tab Detail templates, issue
+    # #33). Fail-closed: any column.label not in `mapping` maps to "(unknown)",
+    # mirroring the ChartPoint arm above. Frozen-dataclass-compliant — we emit
+    # a new tuple of new ColumnSpec instances, never mutate snap.columns.
+    new_columns: list[ColumnSpec] = []
+    for col in snap.columns:
+        if col.kind == "project":
+            new_label = mapping.get(col.label, "(unknown)")
+            new_columns.append(ColumnSpec(
+                key=col.key, label=new_label,
+                align=col.align, emphasis=col.emphasis, kind=col.kind,
+            ))
+        else:
+            new_columns.append(col)
+
     # When ShareSnapshot grows a new field, add it to this constructor — the
     # scrubber must thread every field through to preserve frozen semantics.
     return ShareSnapshot(
@@ -874,7 +909,7 @@ def _apply_anon_mapping(
         title=snap.title,
         subtitle=snap.subtitle,
         period=snap.period,
-        columns=snap.columns,
+        columns=tuple(new_columns),
         rows=tuple(new_rows),
         chart=new_chart,
         totals=snap.totals,
@@ -957,20 +992,292 @@ _SVG_FOOTER_BASELINE = 18
 # Vertical padding between stacked sections in `_stitch_svg`.
 _SVG_SECTION_GAP = 20.0
 
+# --- SVG table geometry (issue #38) ---
+_SVG_TABLE_FONT = 11
+_SVG_TABLE_CELL_PAD_X = 8
+_SVG_TABLE_CELL_PAD_Y = 6
+_SVG_TABLE_LINE_H_MULT = 1.4
+_SVG_TABLE_GAP = 16
+_SVG_TABLE_MAX_WRAP_LINES = 3
+_SVG_TABLE_MIN_COL_W = 24
+_SVG_AVG_GLYPH_WIDTH_FRACTION = 0.6
+_SVG_WRAP_BREAK_CHARS = (" ", "/", "-", "_")
+_SVG_ELLIPSIS = "…"
+
+
+def _svg_text_width(text: str, font_size: float) -> float:
+    """Estimate rendered width of `text` at `font_size` in a sans-serif font.
+
+    Heuristic-only: actual width depends on the UA-selected font. SVG
+    goldens are diffed as source text, so this function's job is
+    determinism, not pixel-perfect measurement. Wrap-then-ellipsize
+    layout tolerates moderate over/under-allocation.
+    """
+    return len(text) * font_size * _SVG_AVG_GLYPH_WIDTH_FRACTION
+
+
+def _wrap_for_width(text: str, content_w: float, font_size: float) -> list[str]:
+    """Wrap `text` into lines that each fit within `content_w` pixels.
+
+    Greedy left-to-right: binary-search the longest prefix that fits,
+    then cut at the rightmost break-char inside the run. Cap output
+    at `_SVG_TABLE_MAX_WRAP_LINES`. If the input still has tail after
+    the cap, ellipsize the last emitted line until ellipsis fits.
+    Empty text → [""]. Unbreakable token longer than `content_w` →
+    hard-cut + ellipsis on the tail.
+    """
+    if not text:
+        return [""]
+    if _svg_text_width(text, font_size) <= content_w:
+        return [text]
+
+    lines: list[str] = []
+    remaining = text
+    while remaining and len(lines) < _SVG_TABLE_MAX_WRAP_LINES:
+        lo, hi = 0, len(remaining)
+        while lo < hi:
+            mid = (lo + hi + 1) // 2
+            if _svg_text_width(remaining[:mid], font_size) <= content_w:
+                lo = mid
+            else:
+                hi = mid - 1
+        fit_end = lo
+
+        if fit_end == len(remaining):
+            lines.append(remaining)
+            remaining = ""
+            break
+
+        if fit_end == 0:
+            # Even one character overflows — abort wrap, fall through to ellipsis.
+            break
+
+        break_at = -1
+        for ch in _SVG_WRAP_BREAK_CHARS:
+            idx = remaining.rfind(ch, 0, fit_end + 1)
+            if idx > break_at:
+                break_at = idx
+
+        if break_at <= 0:
+            lines.append(remaining[:fit_end])
+            remaining = remaining[fit_end:]
+        else:
+            lines.append(remaining[:break_at + 1].rstrip())
+            remaining = remaining[break_at + 1:]
+
+    if remaining:
+        last = lines[-1] if lines else ""
+        while last and _svg_text_width(last + _SVG_ELLIPSIS, font_size) > content_w:
+            last = last[:-1]
+        if last:
+            lines[-1] = last + _SVG_ELLIPSIS
+        elif lines:
+            lines[-1] = _SVG_ELLIPSIS
+        else:
+            lines.append(_SVG_ELLIPSIS)
+
+    return lines or [_SVG_ELLIPSIS]
+
+
+def _svg_table_anchor_and_x(align: str, col_x: float, col_w: float,
+                             pad_x: float) -> tuple[str, float]:
+    """Map `ColumnSpec.align` to SVG text-anchor + x-coordinate."""
+    if align == "right":
+        return "end", col_x + col_w - pad_x
+    if align == "center":
+        return "middle", col_x + col_w / 2
+    return "start", col_x + pad_x
+
+
+def _render_svg_table(
+    snap: "ShareSnapshot", *, palette: dict,
+    x: float, y: float, max_width: float,
+) -> tuple[str, float, float]:
+    """Render the cross-tab / project / sessions table body as SVG.
+
+    Returns (svg_fragment, total_height, used_width). Caller
+    (`_render_svg`) uses the returned height to position the footer
+    band, and `used_width` to size the outer canvas — at pathological
+    `top_n` the min-width clamp can push `sum(widths)` past
+    `max_width`, in which case the outer SVG expands so columns are
+    never clipped (issue #38 follow-up: Codex P2 review on PR #40).
+    Caller MUST short-circuit when `snap.columns` is empty — this
+    helper is a precondition violation
+    if called with `columns=()`.
+
+    Layout: greedy auto-size, shrink only oversized columns, clamp
+    to `_SVG_TABLE_MIN_COL_W` minimum, wrap headers AND body cells
+    with the same break-priority rule. Visual: Treatment A (HTML-
+    mirror) — header band + alternating row stripes + body text;
+    no borders or inter-column rules.
+    """
+    cols = snap.columns
+    rows = snap.rows
+    n = len(cols)
+    assert n > 0, "_render_svg_table: precondition snap.columns non-empty"
+
+    font_size = _SVG_TABLE_FONT
+    pad_x = _SVG_TABLE_CELL_PAD_X
+    pad_y = _SVG_TABLE_CELL_PAD_Y
+    line_h = font_size * _SVG_TABLE_LINE_H_MULT
+
+    # 1. Pre-format every cell to plain text.
+    cell_strs = [
+        [_render_cell_text(row.cells.get(c.key, TextCell("")))
+         for c in cols]
+        for row in rows
+    ]
+
+    # 2. Natural per-column width = max(header, max body) + 2*pad_x.
+    def _col_natural(i: int, c: "ColumnSpec") -> float:
+        widths = [_svg_text_width(c.label, font_size)]
+        for r in range(len(rows)):
+            widths.append(_svg_text_width(cell_strs[r][i], font_size))
+        return max(widths) + 2 * pad_x
+
+    nat_w = [_col_natural(i, c) for i, c in enumerate(cols)]
+
+    # 3+4. Fit or shrink.
+    if sum(nat_w) <= max_width:
+        widths = list(nat_w)
+    else:
+        fair = max_width / n
+        oversize_idx = [i for i in range(n) if nat_w[i] > fair]
+        oversize_set = set(oversize_idx)
+        if not oversize_idx:
+            scale = max_width / sum(nat_w)
+            widths = [w * scale for w in nat_w]
+        else:
+            other_total = sum(nat_w[i] for i in range(n) if i not in oversize_set)
+            total_oversize = sum(nat_w[i] for i in oversize_idx)
+            budget = max_width - other_total
+            scale = budget / total_oversize if total_oversize > 0 else 1.0
+            widths = [
+                (nat_w[i] * scale) if i in oversize_set else nat_w[i]
+                for i in range(n)
+            ]
+        # 4b. Min-width clamp (pathological top_n).
+        widths = [max(w, _SVG_TABLE_MIN_COL_W) for w in widths]
+
+    # 5a. Header wrap.
+    header_lines: list[list[str]] = []
+    for i, c in enumerate(cols):
+        content_w = widths[i] - 2 * pad_x
+        header_lines.append(_wrap_for_width(c.label, content_w, font_size))
+    max_header_lines = max((len(ls) for ls in header_lines), default=1)
+
+    # 5b. Body wrap.
+    wrapped_body: list[list[list[str]]] = []
+    row_lines: list[int] = []
+    for r in range(len(rows)):
+        cells_wrapped: list[list[str]] = []
+        mx = 1
+        for i in range(n):
+            content_w = widths[i] - 2 * pad_x
+            ls = _wrap_for_width(cell_strs[r][i], content_w, font_size)
+            cells_wrapped.append(ls)
+            mx = max(mx, len(ls))
+        wrapped_body.append(cells_wrapped)
+        row_lines.append(mx)
+
+    # 6. Heights.
+    header_h = max_header_lines * line_h + 2 * pad_y
+    body_heights = [nl * line_h + 2 * pad_y for nl in row_lines]
+    total_h = header_h + sum(body_heights)
+
+    # 7. Emit. Column x-offsets are cumulative.
+    col_xs = [x]
+    for w in widths[:-1]:
+        col_xs.append(col_xs[-1] + w)
+
+    # Band rects span the full rendered width — when min-col-w clamp
+    # pushes sum(widths) past max_width, both the header band and the
+    # alternating row stripes extend with the columns so right-side
+    # cells sit on the band color, not on the outer SVG background.
+    used_width = sum(widths)
+    band_width = max(max_width, used_width)
+
+    pieces: list[str] = []
+
+    # Header band.
+    pieces.append(svg_rect(x, y, band_width, header_h,
+                           fill=palette["table_header_bg"]))
+    # Header text.
+    for i, c in enumerate(cols):
+        cx = col_xs[i]
+        cw = widths[i]
+        anchor, tx = _svg_table_anchor_and_x(c.align, cx, cw, pad_x)
+        for j, line in enumerate(header_lines[i]):
+            baseline = y + pad_y + font_size + j * line_h
+            pieces.append(svg_text(
+                tx, baseline, line,
+                font_size=font_size, fill=palette["fg"],
+                anchor=anchor, weight="bold", font_family="sans-serif",
+            ))
+
+    # Body rows.
+    row_y = y + header_h
+    for r, _ in enumerate(rows):
+        rh = body_heights[r]
+        row_bg = palette["table_row_alt"] if (r % 2 == 1) else palette["bg"]
+        pieces.append(svg_rect(x, row_y, band_width, rh, fill=row_bg))
+
+        for i, c in enumerate(cols):
+            cx = col_xs[i]
+            cw = widths[i]
+            anchor, tx = _svg_table_anchor_and_x(c.align, cx, cw, pad_x)
+            for j, line in enumerate(wrapped_body[r][i]):
+                baseline = row_y + pad_y + font_size + j * line_h
+                pieces.append(svg_text(
+                    tx, baseline, line,
+                    font_size=font_size, fill=palette["fg"],
+                    anchor=anchor, font_family="sans-serif",
+                ))
+        row_y += rh
+
+    return "".join(pieces), total_h, used_width
+
 
 def _render_svg(snap: ShareSnapshot, *, palette: dict,
-                branding: bool, include_chrome: bool = True) -> str:
+                branding: bool,
+                include_chrome: bool = True,
+                include_table: bool = True) -> str:
     """Render snapshot to SVG.
 
-    include_chrome=True → standalone SVG with title/subtitle/timestamp/footer.
-    include_chrome=False → chart-only (HTML wrapper consumes this).
+    include_chrome=True  → standalone SVG with title/subtitle/timestamp/footer.
+    include_chrome=False → chart(+optional table)-only (HTML wrapper consumes this).
+    include_table=True   → emit `_render_svg_table` body when snap.columns
+                           is non-empty. HTML wrapper passes False so the
+                           chart-slot embed stays table-free (HTML <table>
+                           is rendered separately as a sibling element).
     """
+    has_table = include_table and bool(snap.columns)
+    chart_h = _SVG_CHART_H if snap.chart is not None else 0
+
+    # Pre-layout the table (we need its height before declaring outer SVG height).
+    if has_table:
+        table_y = _SVG_PADDING + (_SVG_HEADER_H if include_chrome else 0) + chart_h + _SVG_TABLE_GAP
+        table_svg, table_h, table_w = _render_svg_table(
+            snap, palette=palette, x=_SVG_PADDING, y=table_y, max_width=_SVG_WIDTH,
+        )
+    else:
+        table_svg, table_h, table_w = "", 0.0, 0.0
+
+    # Canvas grows when the table's used width exceeds _SVG_WIDTH — happens
+    # only when the min-col-w clamp fired (pathological top_n). Header /
+    # chart / footer keep their original positioning anchored at _SVG_WIDTH;
+    # the canvas just extends to the right so wide tables aren't clipped at
+    # the viewBox. Issue #38 follow-up (Codex PR #40 P2).
+    content_w = max(_SVG_WIDTH, table_w)
+
+    table_block_h = (_SVG_TABLE_GAP + table_h) if has_table else 0
+
     if include_chrome:
-        height = _SVG_HEADER_H + _SVG_CHART_H + _SVG_FOOTER_H + (_SVG_PADDING * 2)
+        height = _SVG_HEADER_H + chart_h + table_block_h + _SVG_FOOTER_H + (_SVG_PADDING * 2)
     else:
-        height = _SVG_CHART_H + (_SVG_PADDING * 2)
+        height = chart_h + table_block_h + (_SVG_PADDING * 2)
 
-    pieces = []
+    pieces: list[str] = []
 
     if include_chrome:
         pieces.append(_render_svg_header(
@@ -978,7 +1285,6 @@ def _render_svg(snap: ShareSnapshot, *, palette: dict,
             x=_SVG_PADDING, y=_SVG_PADDING, width=_SVG_WIDTH,
         ))
 
-    # Chart.
     chart_y = _SVG_PADDING + (_SVG_HEADER_H if include_chrome else 0)
     if snap.chart is not None:
         if isinstance(snap.chart, LineChart):
@@ -997,16 +1303,18 @@ def _render_svg(snap: ShareSnapshot, *, palette: dict,
                 x=_SVG_PADDING, y=chart_y, width=_SVG_WIDTH, height=_SVG_CHART_H,
             ))
 
+    if has_table:
+        pieces.append(table_svg)
+
     if include_chrome:
+        footer_y = _SVG_PADDING + _SVG_HEADER_H + chart_h + table_block_h + _SVG_FOOTER_BASELINE
         pieces.append(_render_svg_footer(
             snap, palette=palette,
-            x=_SVG_PADDING,
-            y=_SVG_PADDING + _SVG_HEADER_H + _SVG_CHART_H + _SVG_FOOTER_BASELINE,
-            width=_SVG_WIDTH,
-            branding=branding,
+            x=_SVG_PADDING, y=footer_y,
+            width=_SVG_WIDTH, branding=branding,
         ))
 
-    total_w = _SVG_WIDTH + (_SVG_PADDING * 2)
+    total_w = content_w + (_SVG_PADDING * 2)
     bg_rect = svg_rect(0, 0, total_w, height, fill=palette["bg"])
     inner = bg_rect + "".join(pieces)
     return (
@@ -1093,7 +1401,7 @@ def _render_html_fragment(snap: ShareSnapshot, *, palette: dict, branding: bool)
     # rather than rendering empty chrome (an empty `<svg>` chart area or an
     # `<table>` with no `<th>`/`<td>`).
     chart_html = (
-        f'<div style="margin-top:12px">{_render_svg(snap, palette=palette, branding=False, include_chrome=False)}</div>'
+        f'<div style="margin-top:12px">{_render_svg(snap, palette=palette, branding=False, include_chrome=False, include_table=False)}</div>'
         if snap.chart is not None else ""
     )
     title_html = f'<h1 style="font-size:20px;color:{palette["fg"]};margin:0">{_xml_escape(snap.title)}</h1>'
@@ -1221,14 +1529,14 @@ def _build_md_frontmatter(snap: ShareSnapshot) -> str:
     """
     period = snap.period
     period_iso = (
-        f"{period.start.isoformat()}.."
-        f"{period.end.isoformat()}"
+        f"{_format_generated_at_iso(period.start)}.."
+        f"{_format_generated_at_iso(period.end)}"
     )
     anonymized = "true" if _snapshot_is_anonymized(snap) else "false"
     lines = [
         "---",
         f"title: {_yaml_scalar(snap.title)}",
-        f"generated_at: {snap.generated_at.isoformat()}",
+        f"generated_at: {_format_generated_at_iso(snap.generated_at)}",
         f"period: {period_iso}",
         f"panel: {snap.cmd}",
     ]
@@ -1260,16 +1568,20 @@ def _yaml_scalar(s: str) -> str:
 
 
 def _snapshot_is_anonymized(snap: ShareSnapshot) -> bool:
-    """Return True if every ProjectCell label is either an anon token or a sentinel.
+    """Return True if every project label (cell or column) is anon or sentinel.
 
     `_scrub` rewrites labels to `project-<N>` (1-indexed, cost-descending).
-    A snapshot with no `ProjectCell` rows returns False (nothing was
-    anonymized because there was nothing to anonymize). `(unknown)` is the
-    project-share sentinel for missing project_path (see
-    `cmd_project`'s `_proj_label_for`) — it is never a revealed real name,
-    so it is counted as also-anonymized. Mixed snapshots (some scrubbed,
-    some revealed) are reported False to keep the frontmatter semantic
-    ("are projects revealed in this MD?").
+    A snapshot with no `ProjectCell` rows AND no `kind='project'` columns
+    returns False (nothing was anonymized because there was nothing to
+    anonymize). `(unknown)` is the project-share sentinel for missing
+    project_path (see `cmd_project`'s `_proj_label_for`) — it is never a
+    revealed real name, so it is counted as also-anonymized. Mixed snapshots
+    (some scrubbed, some revealed) are reported False to keep the
+    frontmatter semantic ("are projects revealed in this MD?").
+
+    Cross-tab Detail templates (issue #33) carry project labels in
+    `kind='project'` columns rather than `ProjectCell` rows; we walk both
+    surfaces so MD frontmatter `anonymized:` stays correct for those panels.
     """
     cells = [
         cell
@@ -1277,11 +1589,16 @@ def _snapshot_is_anonymized(snap: ShareSnapshot) -> bool:
         for cell in row.cells.values()
         if isinstance(cell, ProjectCell)
     ]
-    if not cells:
+    project_cols = [col for col in snap.columns if col.kind == "project"]
+    if not cells and not project_cols:
         return False
-    return all(
-        re.fullmatch(r"project-\d+", c.label) or c.label == "(unknown)"
-        for c in cells
+
+    def _is_anon(label: str) -> bool:
+        return bool(re.fullmatch(r"project-\d+", label)) or label == "(unknown)"
+
+    return (
+        all(_is_anon(c.label) for c in cells)
+        and all(_is_anon(col.label) for col in project_cols)
     )
 
 
@@ -1443,8 +1760,9 @@ def _stitch_md(sections: tuple[ComposedSection, ...], *,
         parts.append(
             "---\n"
             f"title: {_yaml_scalar(opts.title)}\n"
-            f"generated_at: {first_snap.generated_at.isoformat()}\n"
-            f"period: {earliest.isoformat()}..{latest.isoformat()}\n"
+            f"generated_at: {_format_generated_at_iso(first_snap.generated_at)}\n"
+            f"period: {_format_generated_at_iso(earliest)}.."
+            f"{_format_generated_at_iso(latest)}\n"
             f"panel: composed\n"
             f"anonymized: {anon_field}\n"
             f"cctally_version: {first_snap.version}\n"