crowdtime-cli 0.19.0__tar.gz → 0.21.0__tar.gz

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crowdtime-cli
-Version: 0.19.0
+Version: 0.21.0
 Summary: AI-powered time tracking CLI — a modern, developer-friendly alternative to Harvest
 Project-URL: Homepage, https://crowdtime.lat
 Project-URL: Documentation, https://crowdtime.lat/docs

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crowdtime-cli"
-version = "0.19.0"
+version = "0.21.0"
 description = "AI-powered time tracking CLI — a modern, developer-friendly alternative to Harvest"
 readme = "README.md"
 license = {text = "Proprietary"}

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/__init__.py

@@ -1,3 +1,3 @@
 """CrowdTime CLI - AI-powered time tracking from the command line."""
 
-__version__ = "0.19.0"
+__version__ = "0.21.0"

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/commands/pto_cmd.py

@@ -46,12 +46,16 @@ from ..models import (
 )
 from ..utils import format_date, format_duration, parse_date, parse_date_range
 
-app = typer.Typer(name="pto", help="Manage PTO (paid time off) requests.")
+app = typer.Typer(name="pto", help="Manage time off requests.")
+# Hidden from help: nothing may tell someone without paid time off that it
+# exists (CRO-84). Admins and people who have it know where to look.
+allowance_app = typer.Typer(name="allowance", help="Paid time off allowances (admin+).")
+app.add_typer(allowance_app, name="allowance", hidden=True)
 console = Console()
 
 
 # Valid enum values mirrored from the contract.
-_VALID_KINDS = {"vacation", "sick", "holiday", "personal", "other"}
+_VALID_KINDS = {"vacation", "sick", "holiday", "personal", "birthday", "other"}
 _VALID_STATUSES = {"pending", "approved", "rejected", "canceled"}
 
 
@@ -207,7 +211,7 @@ def request_cmd(
         ...,
         help="Date or range: '2026-06-01', '2026-06-01:2026-06-05', 'today', 'next-monday'.",
     ),
-    kind: str = typer.Option("vacation", "--kind", "-k", help="vacation|sick|holiday|personal|other."),
+    kind: str = typer.Option("vacation", "--kind", "-k", help="vacation|sick|holiday|personal|birthday|other. Birthday: one day, once per calendar year."),
     hours_per_day: Optional[str] = typer.Option(
         None, "--hours-per-day",
         help="Decimal hours. Empty/omitted = full day from membership capacity.",
@@ -252,18 +256,12 @@ def add_cmd(
         ...,
         help="Date or range: '2026-06-01', '2026-06-01:2026-06-05', 'today', 'next-monday'.",
     ),
-    kind: str = typer.Option("vacation", "--kind", "-k", help="vacation|sick|holiday|personal|other."),
+    kind: str = typer.Option("vacation", "--kind", "-k", help="vacation|sick|holiday|personal|birthday|other. Birthday: one day, once per calendar year."),
     hours_per_day: Optional[str] = typer.Option(
         None, "--hours-per-day",
         help="Decimal hours per day. Omit for full-day from membership.",
     ),
     notes: Optional[str] = typer.Option(None, "--notes", "-n", help="Optional free-text notes."),
-    paid: Optional[bool] = typer.Option(
-        None, "--paid/--unpaid",
-        help="Whether these hours are paid. Omit to follow the organization's "
-             "policy for this kind. Account managers and above only — the API "
-             "rejects the request from anyone below, it is not ignored.",
-    ),
     output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
 ) -> None:
     """On-behalf PTO entry, auto-approved. Project manager+, within their scope."""
@@ -289,18 +287,13 @@ def add_cmd(
         payload["hours_per_day"] = str(hpd)
     if notes is not None:
         payload["notes"] = notes
-    # Declared since the flag was added but never sent, so --unpaid silently
-    # booked paid leave. The backend defaults every kind to paid, so the
-    # omission was not neutral.
-    if paid is not None:
-        payload["is_paid"] = paid
 
     try:
         data = client.post("/time-off/", data=payload)
     except APIError as e:
         # Surface the rejection as a friendly error — the backend refuses
         # `user` values outside the caller's visible set, refuses it entirely
-        # below project manager, and refuses `is_paid` below account manager.
+        # below project manager.
         format_error(e.message)
         raise typer.Exit(1)
 
@@ -721,3 +714,119 @@ def summary_cmd(
 
     summary = TimeOffSummary(**data)
     console.print(format_timeoff_summary_panel(summary))
+
+
+# ── Paid time off (CRO-84) ──────────────────────────────────────────────
+# Whether someone is paid for leave follows the allowance an admin gave them;
+# nobody flags a request as paid. The API answers 404 to anyone who may not
+# know, so these commands print the same thing for "none" and "not allowed".
+
+
+def _print_balance(data: dict) -> None:
+    b = data.get("balance")
+    name = data.get("name") or data.get("email")
+    days = data.get("paid_time_off_days_per_year")
+    if not b:
+        console.print(f"[bold]{name}[/bold]: no paid time off — their leave is unpaid.")
+        return
+    console.print(
+        f"[bold]{name}[/bold]: {b['remaining_days']} of {b['allowance_days']} paid days left "
+        f"({b['year_start']} → {b['year_end']})"
+    )
+    console.print(
+        f"  used {b['used_days']} · requested {b['pending_days']} · unpaid {b['unpaid_days']}"
+        f"   [dim]{days} days/year from {data.get('paid_time_off_start_date')}[/dim]"
+    )
+
+
+@app.command("balance", hidden=True)
+def balance_cmd(
+    user: Optional[str] = typer.Option(None, "--user", "-u", help="Someone whose leave you approve (email or UUID). Default: you."),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Your paid time off balance, or that of someone whose leave you approve."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+    try:
+        user_id = _resolve_user_to_uuid(client, user) if user else client.current_user_id()
+        data = client.get(f"/members/{user_id}/paid-time-off/")
+    except APIError as e:
+        if e.status_code == 404:
+            console.print("[dim]No balance to show.[/dim]")
+            return
+        format_error(e.message)
+        raise typer.Exit(1)
+    if output_json:
+        print_json(data)
+        return
+    _print_balance(data)
+
+
+@allowance_app.command("list")
+def allowance_list_cmd(
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Every member's paid time off allowance and remaining days. Admin+."""
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+    try:
+        rows = client.get("/members/paid-time-off/").get("results", [])
+    except APIError as e:
+        format_error("Only admins can list allowances." if e.status_code == 404 else e.message)
+        raise typer.Exit(1)
+    if output_json:
+        print_json(rows)
+        return
+    from rich.table import Table
+
+    table = Table(show_header=True, header_style="bold")
+    table.add_column("User ID", style="dim")
+    table.add_column("Name")
+    table.add_column("Days/year", justify="right")
+    table.add_column("Counting from")
+    table.add_column("Left this year", justify="right")
+    for r in rows:
+        b = r.get("balance")
+        table.add_row(
+            r["user_id"], r.get("name") or r.get("email"),
+            str(r["paid_time_off_days_per_year"]) if r.get("paid_time_off_days_per_year") else "—",
+            str(r.get("paid_time_off_start_date") or "—"),
+            str(b["remaining_days"]) if b else "—",
+        )
+    console.print(table)
+
+
+@allowance_app.command("set")
+def allowance_set_cmd(
+    user: str = typer.Argument(..., help="Member (email or UUID)."),
+    days: str = typer.Option(..., "--days", help="Paid days per allowance year; 0 for none."),
+    start: Optional[str] = typer.Option(
+        None, "--from",
+        help="When the allowance starts counting (YYYY-MM-DD): the day they joined, or the day "
+             "this arrangement started. Defaults to the day they joined.",
+    ),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Set someone's paid time off. Admin+, never your own.
+
+    Applies to leave approved from now on; leave already approved keeps what it was paid.
+    """
+    try:
+        value = Decimal(days)
+    except InvalidOperation:
+        format_error(f"--days must be a number, got '{days}'.")
+        raise typer.Exit(1)
+    payload: dict = {"paid_time_off_days_per_year": str(value)}
+    if start:
+        payload["paid_time_off_start_date"] = format_date(_parse_date_or_exit(start))
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+    try:
+        user_id = _resolve_user_to_uuid(client, user)
+        data = client.patch(f"/members/{user_id}/paid-time-off/", data=payload)
+    except APIError as e:
+        format_error("Member not found." if e.status_code == 404 else e.message)
+        raise typer.Exit(1)
+    if output_json:
+        print_json(data)
+        return
+    format_success("Paid time off updated.")
+    _print_balance(data)

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/commands/team_cmd.py

@@ -1,4 +1,4 @@
-"""Team commands: manage manager → direct-report assignments.
+"""Team commands: member profiles and manager → direct-report assignments.
 
 Mirrors Harvest's manager model. Admins assign members as direct reports
 to a manager; the manager can see those members' hours across any project
@@ -11,6 +11,7 @@ concurrent edits from clobbering each other.
 
 from __future__ import annotations
 
+import re
 from typing import List, Optional
 
 import typer
@@ -18,9 +19,9 @@ from rich.console import Console
 from rich.table import Table
 
 from ..client import APIError, CrowdTimeClient
-from ..formatters import extract_results, format_error, format_success, print_json
+from ..formatters import extract_results, format_currency, format_error, format_success, print_json
 
-app = typer.Typer(name="team", help="Manage direct-report assignments.")
+app = typer.Typer(name="team", help="Member profiles and direct-report assignments.")
 console = Console()
 
 
@@ -413,3 +414,175 @@ def reports(
         )
 
     console.print(table)
+
+
+_UUID_RE = re.compile(r"^[0-9a-fA-F-]{36}$")
+
+
+def _resolve_user_id(client: CrowdTimeClient, ref: str) -> str:
+    """User id for ``me``, a user UUID, or an email.
+
+    Emails go through the member list, which project managers and up can read
+    (each within their reach) — everyone else passes ``me`` or the user ID.
+    """
+    if ref.lower() == "me":
+        user_id = client.current_user_id()
+        if not user_id:
+            raise APIError("Could not determine the current user.", status_code=401)
+        return user_id
+    if _UUID_RE.match(ref):
+        return ref
+    try:
+        return _resolve_membership(client, ref)["user"]["id"]
+    except APIError as e:
+        if e.status_code == 403:
+            raise APIError(
+                "Looking members up by email needs project manager access. Use 'me' or the user ID.",
+                status_code=403,
+            )
+        raise
+
+
+def _hours(value) -> str:
+    return f"{float(value or 0):.2f}h"
+
+
+@app.command("show")
+def show(
+    member: str = typer.Argument(..., help="Member: 'me', user ID, or email (email lookup needs project_manager+)."),
+    date_from: Optional[str] = typer.Option(None, "--from", help="Start date YYYY-MM-DD (default: 30 days ago)."),
+    date_to: Optional[str] = typer.Option(None, "--to", help="End date YYYY-MM-DD (default: today)."),
+    output_json: bool = typer.Option(False, "--json", help="Output profile and overview as JSON."),
+) -> None:
+    """Show a member's profile and activity, as far as your role allows.
+
+    Account managers and up can open anyone; others can open themselves and
+    the people on projects they run. Sections you may not see are left out:
+    project managers see only time on their projects, utilization and
+    timesheets are for the person's managers, rates are manager+.
+
+    Examples:
+        ct team show me
+        ct team show alice@acme.com --from 2026-09-01 --to 2026-09-30
+    """
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+    params = {k: v for k, v in (("from", date_from), ("to", date_to)) if v}
+    try:
+        user_id = _resolve_user_id(client, member)
+        profile = client.get(f"/members/{user_id}/")
+        overview = client.get(f"/members/{user_id}/overview/", params=params)
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+    if output_json:
+        print_json({"profile": profile, "overview": overview})
+        return
+
+    user = profile.get("user", {})
+    access = profile.get("access", {})
+    console.print(f"[bold]{user.get('full_name') or user.get('email')}[/bold]  [dim]{profile.get('role')}[/dim]")
+    console.print(f"[dim]User ID:[/dim] {user.get('id')}")
+    console.print(f"[dim]Email:[/dim] {user.get('email')}   [dim]Timezone:[/dim] {user.get('timezone')}")
+    line = f"[dim]Capacity:[/dim] {profile.get('weekly_capacity_hours')}h/week   [dim]Joined:[/dim] {str(profile.get('joined_at', ''))[:10]}"
+    if access.get("money") and profile.get("hourly_rate") is not None:
+        line += f"   [dim]Rate:[/dim] {format_currency(profile['hourly_rate'])}/hr"
+    console.print(line)
+    for label, key in (("Reports to", "managers"), ("Direct reports", "direct_reports")):
+        people = profile.get(key) or []
+        if people:
+            console.print(f"[dim]{label}:[/dim] " + ", ".join(p["name"] for p in people))
+
+    projects = profile.get("projects") or []
+    if projects:
+        table = Table(show_header=True, header_style="bold", title="Assigned projects")
+        table.add_column("Project ID", style="dim")
+        table.add_column("Project")
+        table.add_column("Client", style="dim")
+        table.add_column("Role on project")
+        for p in projects:
+            role = (p.get("effective_role") or p.get("project_role") or "-").replace("_", " ")
+            table.add_row(p["id"], p["name"], p.get("client_name") or "-", role)
+        console.print(table)
+
+    timer = overview.get("running_timer")
+    if timer:
+        task = f" / {timer['task_name']}" if timer.get("task_name") else ""
+        console.print(f"[green]Tracking now:[/green] {timer['project_name']}{task} (since {timer['started_at']})")
+
+    if access.get("level") == "profile":
+        console.print("\n[dim]Profile only — time details are for this person's managers and project managers.[/dim]")
+    else:
+        if access.get("level") == "projects":
+            console.print("\n[dim]Showing time on the projects you run.[/dim]")
+        summary = overview.get("summary") or {}
+        console.print(f"\n[bold]{overview.get('from')} → {overview.get('to')}[/bold]")
+        stats = [
+            f"Hours {_hours(summary.get('total_hours'))}",
+            f"Billable {summary.get('billable_percent', 0)}%",
+            f"Entries {summary.get('entry_count', 0)}",
+            f"Days logged {summary.get('days_logged', 0)}",
+        ]
+        if "utilization_percent" in summary and summary["utilization_percent"] is not None:
+            stats.append(f"Utilization {summary['utilization_percent']}% of {summary.get('capacity_hours')}h")
+        if access.get("money") and summary.get("billable_amount") is not None:
+            stats.append(f"Billable amount {format_currency(summary['billable_amount'])}")
+        console.print("   ".join(stats))
+
+        by_project = overview.get("by_project") or []
+        if by_project:
+            table = Table(show_header=True, header_style="bold", title="By project")
+            table.add_column("Project ID", style="dim")
+            table.add_column("Project")
+            table.add_column("Client", style="dim")
+            table.add_column("Hours", justify="right")
+            table.add_column("Billable", justify="right")
+            if access.get("money"):
+                table.add_column("Amount", justify="right")
+            for p in by_project:
+                row = [p["project_id"], p["project_name"], p.get("client_name") or "-",
+                       _hours(p["hours"]), _hours(p["billable_hours"])]
+                if access.get("money"):
+                    row.append(format_currency(p.get("billable_amount")))
+                table.add_row(*row)
+            console.print(table)
+
+        recent = overview.get("recent_entries") or []
+        if recent:
+            table = Table(show_header=True, header_style="bold", title="Recent entries")
+            table.add_column("Date")
+            table.add_column("Project")
+            table.add_column("Task", style="dim")
+            table.add_column("Hours", justify="right")
+            table.add_column("Notes", style="dim")
+            for e in recent:
+                table.add_row(e["date"], e["project_name"], e.get("task_name") or "-", _hours(e["hours"]), e.get("notes") or "")
+            console.print(table)
+
+    timesheets = overview.get("timesheets")
+    if timesheets:
+        table = Table(show_header=True, header_style="bold", title="Timesheets")
+        table.add_column("Period")
+        table.add_column("Status")
+        table.add_column("Hours", justify="right")
+        for p in timesheets["periods"]:
+            hours = _hours(p["total_hours"]) if p.get("total_hours") is not None else "-"
+            table.add_row(f"{p['period_start']} → {p['period_end']}", p["status"], hours)
+        console.print(table)
+        if timesheets.get("submitted_rate") is not None:
+            console.print(f"[dim]Submitted on {timesheets['submitted_rate']}% of recent weeks, {timesheets.get('missing_count', 0)} missing.[/dim]")
+
+    time_off = overview.get("time_off")
+    if time_off:
+        kinds = ", ".join(f"{k} {v}d" for k, v in time_off.get("days_by_kind", {}).items()) or "none"
+        console.print(f"\n[bold]Time off {time_off.get('year')}:[/bold] {time_off.get('total_days', 0)} approved days ({kinds})")
+        bal = time_off.get("balance")  # only present for those allowed to see paid leave
+        if bal:
+            console.print(
+                f"  paid time off: {bal['remaining_days']} of {bal['allowance_days']} days left "
+                f"({bal['year_start']} → {bal['year_end']}), {bal['unpaid_days']} unpaid"
+            )
+        elif "balance" in time_off:
+            console.print("  no paid time off: their leave is unpaid")
+        for row in time_off.get("upcoming", []):
+            console.print(f"  upcoming: {row['start_date']} → {row['end_date']}  {row['kind']}  [{row['status']}]")

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/commands/timesheet_cmd.py

@@ -1,4 +1,4 @@
-"""Timesheet commands: list, submit, approve, reject, recall, reopen, team overview."""
+"""Timesheet commands: list, submit, remind, approve, reject, recall, reopen, team overview."""
 
 from __future__ import annotations
 
@@ -246,17 +246,27 @@ def submit_timesheet(
     period_end: str = typer.Option(
         ..., "--to", help="Period end date (YYYY-MM-DD or keyword)."
     ),
+    user: Optional[str] = typer.Option(
+        None, "--user", "-u",
+        help="Submit on someone's behalf (email or UUID). Reviewers only.",
+    ),
     force: bool = typer.Option(False, "--force", "-f", help="Skip confirmation prompt."),
     output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
 ) -> None:
     """Submit a timesheet for approval.
 
-    Computes total hours from your time entries in the given period.
+    Computes total hours from the time entries in the given period.
     Shows a preview of hours before submitting (use --force to skip).
 
+    --user submits a week someone logged but never sent. It needs the same
+    authority as approving their whole timesheet (admin, their manager, or
+    running every project they logged on); the submission is then reviewed
+    as usual.
+
     Examples:
         ct timesheet submit --from 2026-03-09 --to 2026-03-15
         ct timesheet submit --from monday --to friday --force
+        ct timesheet submit --from 2026-03-09 --to 2026-03-15 --user ana@acme.com
     """
     try:
         start = format_date(parse_date(period_start))
@@ -267,13 +277,23 @@ def submit_timesheet(
 
     client = CrowdTimeClient(require_auth=True, require_org=True)
 
+    user_id = None
+    if user:
+        from .pto_cmd import _resolve_user_to_uuid
+
+        try:
+            user_id = _resolve_user_to_uuid(client, user)
+        except APIError as e:
+            format_error(e.message)
+            raise typer.Exit(1)
+
     # Preview: fetch entries for the period and show summary before confirming
     if not force and not output_json:
         try:
-            entries_data = client.get("/time-entries/", params={
-                "date_from": start,
-                "date_to": end,
-            })
+            entry_params = {"date_from": start, "date_to": end}
+            if user_id:
+                entry_params["user"] = user_id
+            entries_data = client.get("/time-entries/", params=entry_params)
             entries = extract_results(entries_data)
             total_h = sum(Decimal(str(e.get("hours", 0))) for e in entries)
             billable_h = sum(
@@ -296,10 +316,10 @@ def submit_timesheet(
             pass  # If preview fails, proceed to submit (server will validate)
 
     try:
-        result = client.post("/timesheets/submit/", data={
-            "period_start": start,
-            "period_end": end,
-        })
+        payload = {"period_start": start, "period_end": end}
+        if user_id:
+            payload["user_id"] = user_id
+        result = client.post("/timesheets/submit/", data=payload)
 
         if output_json:
             print_json(result)
@@ -316,6 +336,50 @@ def submit_timesheet(
         raise typer.Exit(1)
 
 
+@app.command("remind")
+def remind_timesheet(
+    user: str = typer.Option(..., "--user", "-u", help="Who to remind (email or UUID)."),
+    period_start: str = typer.Option(
+        ..., "--from", help="Period start date (YYYY-MM-DD or keyword)."
+    ),
+    period_end: str = typer.Option(
+        ..., "--to", help="Period end date (YYYY-MM-DD or keyword)."
+    ),
+    output_json: bool = typer.Option(False, "--json", help="Output as JSON."),
+) -> None:
+    """Email someone a reminder to submit their timesheet (project_manager+).
+
+    For a week they haven't submitted. One reminder per person and period an hour.
+
+    Examples:
+        ct timesheet remind --user ana@acme.com --from 2026-03-09 --to 2026-03-15
+    """
+    from .pto_cmd import _resolve_user_to_uuid
+
+    try:
+        start = format_date(parse_date(period_start))
+        end = format_date(parse_date(period_end))
+    except ValueError as e:
+        format_error(str(e))
+        raise typer.Exit(1)
+
+    client = CrowdTimeClient(require_auth=True, require_org=True)
+    try:
+        user_id = _resolve_user_to_uuid(client, user)
+        result = client.post("/timesheets/remind/", data={
+            "user_id": user_id,
+            "period_start": start,
+            "period_end": end,
+        })
+        if output_json:
+            print_json(result)
+        else:
+            format_success(f"Reminder sent to {user} for {start} → {end}.")
+    except APIError as e:
+        format_error(e.message)
+        raise typer.Exit(1)
+
+
 @app.command("approve")
 def approve_timesheet(
     timesheet_id: str = typer.Argument(..., help="Timesheet ID to approve."),

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/formatters.py

@@ -710,6 +710,9 @@ def format_timeoff_detail(entry: TimeOffEntry) -> Panel:
 
     table.add_row("Kind", _pto_kind_label(entry))
     table.add_row("Status", _pto_status_label(entry))
+    pay = _pto_pay_label(entry)  # empty unless the API sent the split (CRO-84)
+    if pay:
+        table.add_row("Paid", pay)
     table.add_row("Notes", entry.notes or "[dim](none)[/dim]")
 
     table.add_row("", "")  # spacer
@@ -729,7 +732,7 @@ def format_timeoff_detail(entry: TimeOffEntry) -> Panel:
         table.add_row("Updated", format_iso_datetime(str(entry.updated_at)))
 
     border = _pto_status_style(entry.status)
-    title = f"PTO {entry.id}"
+    title = f"Time off {entry.id}"
     return Panel(table, title=title, border_style=border, padding=(0, 1))
 
 
@@ -740,7 +743,7 @@ def format_timeoff_table(
 ) -> Table:
     """Tabular view. Returns the Rich Table for caller-side printing."""
     table = Table(show_header=True, header_style="bold", title=None)
-    table.add_column("ID", style="dim", width=36)  # full UUID
+    table.add_column("ID", style="dim", min_width=36, no_wrap=True)  # full UUID, never truncated
     if show_user:
         table.add_column("User", width=20)
     table.add_column("Dates", width=25)
@@ -748,7 +751,15 @@ def format_timeoff_table(
     table.add_column("Hours", justify="right", width=8)
     table.add_column("Kind", width=10)
     table.add_column("Status", width=10)
-    table.add_column("Notes", width=40)
+    # Paid/unpaid split, only when the API sent it — it never does to someone
+    # who isn't allowed to know paid leave exists (CRO-84).
+    show_pay = any(
+        getattr(e, "paid_days", None) is not None or getattr(e, "pay_preview", None)
+        for e in entries
+    )
+    if show_pay:
+        table.add_column("Paid", width=16)
+    table.add_column("Notes", width=24 if show_pay else 40)
 
     for e in entries:
         start = e.start_date.isoformat() if e.start_date else "—"
@@ -763,12 +774,32 @@ def format_timeoff_table(
             format_duration(hours),
             _pto_kind_label(e),
             _pto_status_label(e),
-            truncate(e.notes or "", 40),
         ])
+        if show_pay:
+            row.append(_pto_pay_label(e))
+        row.append(truncate(e.notes or "", 24 if show_pay else 40))
         table.add_row(*row)
     return table
 
 
+def _pto_pay_label(entry: Any) -> str:
+    """'3 paid · 2 unpaid' for approved entries, 'if approved: …' for pending."""
+    def label(paid, unpaid) -> str:
+        parts = []
+        if paid and Decimal(str(paid)) > 0:
+            parts.append(f"{paid} paid")
+        if unpaid and Decimal(str(unpaid)) > 0:
+            parts.append(f"{unpaid} unpaid")
+        return " · ".join(parts) or "unpaid"
+
+    if getattr(entry, "paid_days", None) is not None:
+        return label(entry.paid_days, entry.unpaid_days)
+    preview = getattr(entry, "pay_preview", None)
+    if preview:
+        return "if approved: " + label(preview.get("paid_days"), preview.get("unpaid_days"))
+    return ""
+
+
 def format_timeoff_calendar(
     items: list[TimeOffCalendarItem],
     from_date: date,

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/models.py

@@ -282,11 +282,10 @@ class TimeOffEntryListItem(BaseModel):
     days_count: int = 0
     kind: str = "vacation"
     kind_display: str = ""
-    # Explicit override; None follows the org policy for the kind.
-    is_paid: bool | None = None
-    # Effective paid/unpaid after resolution. Unpaid hours explain the absence
-    # but do not count towards the hours the person is paid for.
-    resolved_is_paid: bool = True
+    # Paid/unpaid split (CRO-84) — only sent to those allowed to see it.
+    paid_days: Decimal | None = None
+    unpaid_days: Decimal | None = None
+    pay_preview: dict | None = None
     status: str = "pending"
     status_display: str = ""
     resolved_hours_per_day: Decimal | None = None
@@ -312,8 +311,9 @@ class TimeOffEntry(BaseModel):
     total_hours: Decimal | None = None
     kind: str = "vacation"
     kind_display: str = ""
-    is_paid: bool | None = None
-    resolved_is_paid: bool = True
+    paid_days: Decimal | None = None
+    unpaid_days: Decimal | None = None
+    pay_preview: dict | None = None
     status: str = "pending"
     status_display: str = ""
     notes: str = ""

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/skills/crowdtime/SKILL.md

@@ -300,6 +300,8 @@ ct timesheet list                       # List your timesheets
 ct timesheet list --status submitted    # Filter by status
 ct timesheet submit --from 2026-03-10 --to 2026-03-16  # Submit full week
 ct timesheet submit --from 2026-03-30 --to 2026-03-31  # Partial week (end-of-month split)
+ct timesheet submit --from 2026-03-10 --to 2026-03-16 --user ana@acme.com  # Submit a week someone logged but never sent (same authority as whole approve)
+ct timesheet remind --user ana@acme.com --from 2026-03-10 --to 2026-03-16  # Email them a reminder to submit (project_manager+)
 ct timesheet recall <id>                # Recall submitted timesheet back to draft (--force to skip confirm)
 ct timesheet approve <id>               # Approve the whole timesheet (admin, direct manager, or PM of every project in it)
 ct timesheet approve <id> --project <project-id>  # Approve one project's portion (PM for that project)
@@ -424,7 +426,7 @@ ct log 0.25 --project argo --task BE --notes "Daily standup"
 
 ### Time Off (PTO)
 
-Per-user time-off entries with a kind (vacation, sick, holiday, personal, other) and a status lifecycle (pending → approved/rejected; pending → canceled). Members submit requests that await approval, and their approvers are emailed automatically; project managers and above can also add PTO directly on behalf of someone in their scope (auto-approved).
+Per-user time-off entries with a kind (vacation, sick, holiday, personal, birthday, other) and a status lifecycle (pending → approved/rejected; pending → canceled). Members submit requests that await approval, and their approvers are emailed automatically; project managers and above can also add PTO directly on behalf of someone in their scope (auto-approved).
 
 > **IMPORTANT**: Never use magic routing (`ct "..."`) or `ct ai parse` for PTO operations. Always construct explicit `ct pto ...` commands.
 > Full reference: `references/pto.md` and `references/commands.md` § PTO.
@@ -432,7 +434,6 @@ Per-user time-off entries with a kind (vacation, sick, holiday, personal, other)
 ```bash
 ct pto request <dates>                # Submit your own PTO request (status=pending)
 ct pto add <user> <dates>             # Add PTO on behalf of user, auto-approved (project manager+, in scope)
-ct pto add <user> <dates> --unpaid    # ... marked unpaid (account manager+; 400 for anyone below, not ignored)
 ct pto list [--mine|--team]           # List PTO entries with optional filters
 ct pto show <id>                      # Detail view of a single PTO entry (NEVER truncate the ID)
 ct pto edit <id> [fields]             # Edit date range, kind, notes, hours/day (your own: pending only)
@@ -472,8 +473,11 @@ ct payroll payments --period 2026-03 --status paid
 
 **Workflow**: Configure compensation → Run liquidation → Approve → Mark paid.
 
-### Team (Direct Reports)
+### Team (Member Profiles and Direct Reports)
 ```bash
+ct team show me                                        # Your own profile, hours, utilization, timesheets, time off
+ct team show <user-id> --from 2026-09-01 --to 2026-09-30   # A member's page; sections follow your access (see below)
+ct team show alice@co.com                              # Email lookup needs project_manager+; others use the user ID
 ct team list                                           # All direct-report assignments (admin+) or your own
 ct team list --manager alice@company.com               # Filter to a specific manager
 ct team reports                                        # Show YOUR direct reports
@@ -488,6 +492,8 @@ ct team set alice@co.com                               # Clear all (zero --membe
 ct team set alice@co.com --all                         # Set her reports to the full org
 ```
 
+`ct team show` returns only what you may see: its `access.level` is `full` (yourself, your direct reports, or everyone for admins), `projects` (people on projects you run — their time on those projects only), or `profile` (profile only). Missing sections mean no access, not no data — don't report them as zero.
+
 All mutating commands (`assign`, `unassign`, `set`) hit the atomic `bulk-set` endpoint — changes apply in a single transaction and the response reports `added` / `removed` / `skipped` buckets.
 
 **Visibility rule** — what a `manager` or `project_manager` sees of other people:

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/skills/crowdtime/references/commands.md

@@ -1562,7 +1562,7 @@ Switches active organization. Saves to config `defaults.organization`.
 ct org members [--json]
 ```
 
-Shows: Name, Email, Role, Projects, Status. Requires manager+ role. Each member carries `projects[]` in JSON — `{id, name, code, status, project_role}` for every project they are on; `project_role` is `"project_manager"` when they run it (shown as "(PM)" in the table). Endpoint: `GET /members/`
+Shows: Name, Email, Role, Projects, Status. Requires project_manager+. Account managers and up see every member; a project manager sees the people they reach (themselves, their direct reports, the people on projects they run), and of each person only the projects they share with them — rates are null below manager. Each member carries `projects[]` in JSON — `{id, name, code, status, project_role}` for every project they are on; `project_role` is `"project_manager"` when they run it (shown as "(PM)" in the table). Endpoint: `GET /members/`
 
 ### ct org invite
 
@@ -1735,13 +1735,14 @@ Lists your timesheets, plus — for managers and project managers — the timesh
 ### ct timesheet submit
 
 ```
-ct timesheet submit --from DATE --to DATE [--force/-f] [--json]
+ct timesheet submit --from DATE --to DATE [--user/-u USER] [--force/-f] [--json]
 ```
 
 | Option | Type | Description |
 |--------|------|-------------|
 | `--from` | string (required) | Period start date |
 | `--to` | string (required) | Period end date |
+| `--user`, `-u` | string | Submit on someone's behalf (email or UUID) |
 | `--force`, `-f` | flag | Skip confirmation prompt |
 | `--json` | flag | JSON output |
 
@@ -1749,6 +1750,23 @@ Submits a timesheet for the given period (any date range — not limited to full
 
 A zero-hour period is rejected **unless every working day in it is covered by approved time off** — a full vacation week has no time entries by design and is submitted as-is. If someone was away and the submit is rejected, the fix is an approved PTO entry (`ct pto request`), not a fake time entry. Endpoint: `POST /timesheets/submit/`
 
+`--user` submits a week someone logged but never sent (body `user_id`). It needs the same authority as approving their whole timesheet — admin/owner, their direct manager, or running every project they logged on that period — otherwise `403`. The submission is recorded as theirs (the audit event names who sent it) and is then approved or rejected as usual. To nudge them to do it themselves, use `ct timesheet remind`.
+
+### ct timesheet remind
+
+```
+ct timesheet remind --user USER --from DATE --to DATE [--json]
+```
+
+| Option | Type | Description |
+|--------|------|-------------|
+| `--user`, `-u` | string (required) | Who to remind (email or UUID) |
+| `--from` | string (required) | Period start date |
+| `--to` | string (required) | Period end date |
+| `--json` | flag | JSON output |
+
+Emails the person a reminder to submit their timesheet for the period, naming who asked (project_manager+, anyone on your roster — `ct timesheet viewable-users`). Refused with `400` when a timesheet for the period is already submitted or approved, and with `429` when that person was reminded about the same period less than an hour ago. Endpoint: `POST /timesheets/remind/` → `202`.
+
 ### ct timesheet approve
 
 ```
@@ -2586,6 +2604,29 @@ Endpoint: `GET /insights/profitability/`
 
 Manage manager → direct-report assignments. Mirrors Harvest's manager model: assign people to a manager so the manager can see their hours across any project without being a PM on each project individually. Orthogonal to per-project PM assignments; visibility is the union of both.
 
+### ct team show
+
+```
+ct team show MEMBER [--from DATE] [--to DATE] [--json]
+```
+
+One member's profile and activity — the CLI view of the web member page. `MEMBER` is `me`, a user ID, or an email; email lookup reads the member list (project_manager+, within their reach), so members and viewers pass `me` or the user ID. Defaults to the last 30 days; the range can be at most 366 days.
+
+What comes back depends on who is asking, and sections the caller may not see are **left out** of the response, not nulled. `access.level` says which case applies:
+- `full` — themselves, their people manager (direct reports via `ct team`), admins/owners. Hours, billable %, weekly trend, breakdown by project/client/task, recent entries, running timer, plus utilization against capacity and the last 8 timesheet periods (`missing` = never submitted).
+- `projects` — someone who runs (explicit `project_role=project_manager`) a project the person works on. The same time sections, limited to the caller's projects; no utilization or timesheets.
+- `profile` — anyone else who can reach the person (account managers see the whole roster). Name, role, capacity, joined date, and projects (below manager: only projects shared with the caller).
+
+Every level includes `profile.projects[]`: the projects the person is assigned to, each with `effective_role` — what the assignment grants on that project (`project_manager`, `member`, `viewer`; an org-level project manager without an explicit project role is a plain `member` there). Below manager, only projects shared with the caller are listed.
+
+`time_off` (upcoming, recent, approved days by kind this year) is included for the person themselves and for org-level people managers who reach them. Rates and billable amounts are manager+ and never shown on your own profile; pay is not part of this view — use `ct payroll`. A person outside your reach answers `404`.
+
+**Options:**
+- `--from DATE` / `--to DATE` — period (YYYY-MM-DD)
+- `--json` — `{"profile": ..., "overview": ...}`
+
+Endpoints: `GET /members/<user_id>/`, `GET /members/<user_id>/overview/?from=&to=`
+
 ### ct team list
 
 ```
@@ -2717,7 +2758,7 @@ Submit a PTO request for yourself. Created with `status=pending` — must be app
 | Argument/Option | Type | Required | Description |
 |-----------------|------|----------|-------------|
 | `<dates>` | string | yes | `YYYY-MM-DD` or `YYYY-MM-DD:YYYY-MM-DD` |
-| `--kind`, `-k` | string | no | `vacation` (default), `sick`, `holiday`, `personal`, `other` |
+| `--kind`, `-k` | string | no | `vacation` (default), `sick`, `holiday`, `personal`, `birthday` (one day, once per calendar year), `other` |
 | `--hours-per-day`, `-h` | decimal | no | Hours/day. Empty = capacity-based default (see `references/pto.md`) |
 | `--notes`, `-n` | string | no | Reason or notes |
 | `--json` | flag | no | JSON output |
@@ -2763,10 +2804,9 @@ Add a PTO entry on behalf of another user (project manager and above). The entry
 |-----------------|------|----------|-------------|
 | `<user>` | string | yes | User email or UUID |
 | `<dates>` | string | yes | `YYYY-MM-DD` or `YYYY-MM-DD:YYYY-MM-DD` |
-| `--kind`, `-k` | string | no | `vacation` (default), `sick`, `holiday`, `personal`, `other` |
+| `--kind`, `-k` | string | no | `vacation` (default), `sick`, `holiday`, `personal`, `birthday` (one day, once per calendar year), `other` |
 | `--hours-per-day`, `-h` | decimal | no | Hours/day. Empty = capacity-based default |
 | `--notes`, `-n` | string | no | Reason or context notes |
-| `--paid` / `--unpaid` | flag | no | Whether the hours are paid. **Account manager+ only** — sending it as a project manager returns `400`, it is NOT ignored. Omit to follow the org policy for the kind |
 | `--json` | flag | no | JSON output |
 
 **Response (201):** full entry serializer with `status=approved`, `decided_by=<your user>`, `decided_at=<now>`.
@@ -2777,8 +2817,6 @@ Add a PTO entry on behalf of another user (project manager and above). The entry
 - `400` on the `user` field — caller is below `project_manager`, or the named
   user is outside the caller's visibility scope. This is a `400`, not a `403`:
   the check lives in the serializer, so treat it as a validation error.
-- `400` on the `is_paid` field — caller is below account manager and sent
-  `--paid`/`--unpaid`.
 
 **Usage examples:**
 

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/skills/crowdtime/references/pto.md

@@ -25,31 +25,13 @@ A `TimeOffEntry` represents a block of time off for a single user within an orga
 | `sick` | Sick Leave | Illness, medical appointment, recovery. |
 | `holiday` | Public Holiday | National or regional public holiday observed by the org. |
 | `personal` | Personal Day | Personal errands, family obligations, other non-vacation personal time. |
+| `birthday` | Birthday | The person's birthday day off. **One day, once per calendar year** — a second one in the same year, or a multi-day range, is rejected. |
 | `other` | Other | Anything that doesn't fit the above categories. |
 
 If the user doesn't specify a kind, default to `vacation` but **confirm before submitting**.
 
 ---
 
-## Paid vs unpaid
-
-Every entry resolves to paid or unpaid, exposed as `resolved_is_paid`:
-
-1. The entry's own `is_paid`, when set.
-2. Otherwise the organization's policy for that kind (`time_off_paid_kinds`).
-3. Otherwise paid.
-
-**Paid** hours count towards the hours a person is paid for that month. **Unpaid**
-hours still explain the absence — reports and anomaly checks treat the person as
-away either way — but do not count towards what they are paid.
-
-Only account managers and above can set `is_paid`, via `ct pto add --paid/--unpaid`. A project manager passing the flag gets a `400` on the `is_paid` field — the request is refused, not silently booked under the org default. Omit the flag and the organization's policy for the kind applies. The same holds on update: changing `is_paid` on an existing entry is refused (`400`) below account manager.
-A member submitting their own request never chooses; it follows the org policy.
-Do not tell a user their leave is paid because they asked for it — read
-`resolved_is_paid` back from the entry.
-
----
-
 ## Status lifecycle
 
 ```

{crowdtime_cli-0.19.0 → crowdtime_cli-0.21.0}/src/crowdtime_cli/skills/crowdtime/references/workflows.md

@@ -444,6 +444,9 @@ ct report team --week
 # Specific member
 ct report team --month --member john@company.com
 
+# One person in depth: hours trend, projects, timesheet history, time off
+ct team show john@company.com --from 2026-09-01 --to 2026-09-30
+
 # List all members
 ct org members
 ```
@@ -631,6 +634,11 @@ ct timesheet reject <timesheet-id> --notes "Missing entries for Wednesday — pl
 # Reject multiple timesheets at once
 ct timesheet bulk-reject <id1> <id2> --notes "Incomplete entries for the week"
 
+# Someone logged the week but never submitted ("No timesheet" in `ct timesheet team`)?
+# There's nothing to reopen — nudge them, or submit it for them and then approve it
+ct timesheet remind --user ana@acme.com --from 2026-03-09 --to 2026-03-15
+ct timesheet submit --from 2026-03-09 --to 2026-03-15 --user ana@acme.com --force
+
 # Approved it too early? Reopen — back to draft, entries unlocked, user fixes & resubmits
 ct timesheet reopen <timesheet-id> --notes "Approved before Friday's entries were added"
 ct timesheet reopen <timesheet-id> --notes "Wrong project on Tuesday" --force
@@ -1474,7 +1482,7 @@ Use this when a member wants to request time off. The request goes into `pending
 
 **Before running any command, ask the user:**
 1. What dates? (single day or range) — if they say "next week" or "a few days in June", ASK for the exact dates. Never assume.
-2. What kind? (vacation / sick / holiday / personal / other) — if not specified, default to `vacation` and confirm.
+2. What kind? (vacation / sick / holiday / personal / birthday / other) — if not specified, default to `vacation` and confirm. Birthday is a single day, once per calendar year.
 3. Hours per day? — leave empty unless they want partial days (e.g. half-day sick leave).
 4. Notes? — optional but useful for the manager.