feat: support prolite plan (#54)

* fix: recognize prolite plan

Parse prolite across auth, session, registry, and usage paths.
Render the CLI label as 'pro lite'.

Tested: zig build run -- list
Tested: zig build test

* fix: unify human-readable plan labels

* test: relax prolite grouped label example

* docs: clarify grouped plan label rules

---------

Co-authored-by: Loongphy <Loongphy@outlook.com>

Author: notcheesex

docs/api-refresh.md

@@ -92,8 +92,8 @@ After a successful `accounts/check` response:
 
 Example 1:
 
-- active record: `user@example.com / team #1 / account_name = null`
-- same grouped scope: `user@example.com / team #2 / account_name = null`
+- active record: `user@example.com / Team #1 / account_name = null`
+- same grouped scope: `user@example.com / Team #2 / account_name = null`
 
 Running `codex-auth list` should issue `accounts/check`. If the API returns:
 
@@ -104,9 +104,9 @@ Then both grouped Team records are updated.
 
 Example 2:
 
-- active record: `user@example.com / pro / account_name = null`
-- same grouped scope: `user@example.com / team #1 / account_name = null`
-- same grouped scope: `user@example.com / team #2 / account_name = "Old Workspace"`
+- active record: `user@example.com / Pro / account_name = null`
+- same grouped scope: `user@example.com / Team #1 / account_name = null`
+- same grouped scope: `user@example.com / Team #2 / account_name = "Old Workspace"`
 
 Running `codex-auth list` should still issue `accounts/check`, because the grouped scope still has missing Team names. If the API returns:
 
@@ -115,7 +115,7 @@ Running `codex-auth list` should still issue `accounts/check`, because the group
 
 Then:
 
-- `team #1` is filled with `Prod Workspace`
-- `team #2` is overwritten from `Old Workspace` to `Sandbox Workspace`
+- `Team #1` is filled with `Prod Workspace`
+- `Team #2` is overwritten from `Old Workspace` to `Sandbox Workspace`
 
 The same grouped-scope rule also applies to synchronous `list` / pre-selection `switch` refreshes and to the auto-switch daemon.

docs/implement.md

@@ -293,10 +293,11 @@ Latest rollout `.jsonl` rate limit record shape (from an `event_msg` + `token_co
   - the top-level email line is a header only
   - child rows are the selectable accounts
   - alias takes precedence for the child label
-  - otherwise the child label is the plan name (`team`, `plus`, etc.)
-  - repeated plans under the same email are rendered as stable numbered labels like `team #1`, `team #2`
+  - otherwise the child label is the human-readable plan name (`Team`, `Plus`, `Pro Lite`, etc.)
+  - workspace-style duplicate plans may use stable numbered labels like `Team #1`, `Team #2`
+  - non-workspace duplicate plans (`Free`, `Plus`, `Pro`, `Pro Lite`) do not use `#1` / `#2`; they should use another disambiguator such as an account or user suffix
 - Single-account emails still render as one flat row; when an alias is set, that row shows `(alias)email`.
 - The switch/remove UI shows `ACCOUNT`, `PLAN`, `5H`, `WEEKLY`, `LAST`, and preserves grouped child indentation.
 - Usage limit cells show remaining percent plus reset time: `NN% (HH:MM)` for same-day resets, or `NN% (HH:MM on D Mon)` when the reset is on a different day.
 - `LAST ACTIVITY` is derived from `last_usage_at` and rendered as a relative time like `Now` or `2m ago`.
-- `PLAN` comes from the auth claim when available, and falls back to the last usage snapshot's `plan_type` (e.g. `free`, `plus`, `team`).
+- `PLAN` comes from the auth claim when available, and falls back to the last usage snapshot's `plan_type` (for example raw values like `free`, `plus`, `prolite`, `team` are shown as `Free`, `Plus`, `Pro Lite`, `Team`).

src/auth.zig

@@ -275,6 +275,7 @@ fn base64UrlNoPadDecode(allocator: std.mem.Allocator, input: []const u8) ![]u8 {
 fn parsePlanType(s: []const u8) registry.PlanType {
     if (std.ascii.eqlIgnoreCase(s, "free")) return .free;
     if (std.ascii.eqlIgnoreCase(s, "plus")) return .plus;
+    if (std.ascii.eqlIgnoreCase(s, "prolite")) return .prolite;
     if (std.ascii.eqlIgnoreCase(s, "pro")) return .pro;
     if (std.ascii.eqlIgnoreCase(s, "team")) return .team;
     if (std.ascii.eqlIgnoreCase(s, "business")) return .business;

src/cli.zig

@@ -1821,7 +1821,7 @@ fn buildSwitchRows(allocator: std.mem.Allocator, reg: *registry.Registry) !Switc
     for (display.rows, 0..) |display_row, i| {
         if (display_row.account_index) |account_idx| {
             const rec = reg.accounts.items[account_idx];
-            const plan = if (registry.resolvePlan(&rec)) |p| @tagName(p) else "-";
+            const plan = if (registry.resolvePlan(&rec)) |p| registry.planLabel(p) else "-";
             const rate_5h = resolveRateWindow(rec.last_usage, 300, true);
             const rate_week = resolveRateWindow(rec.last_usage, 10080, false);
             const rate_5h_str = try formatRateLimitSwitchAlloc(allocator, rate_5h);
@@ -1885,7 +1885,7 @@ fn buildSwitchRowsFromIndices(
     for (display.rows, 0..) |display_row, i| {
         if (display_row.account_index) |account_idx| {
             const rec = reg.accounts.items[account_idx];
-            const plan = if (registry.resolvePlan(&rec)) |p| @tagName(p) else "-";
+            const plan = if (registry.resolvePlan(&rec)) |p| registry.planLabel(p) else "-";
             const rate_5h = resolveRateWindow(rec.last_usage, 300, true);
             const rate_week = resolveRateWindow(rec.last_usage, 10080, false);
             const rate_5h_str = try formatRateLimitSwitchAlloc(allocator, rate_5h);

src/display_rows.zig

@@ -139,13 +139,13 @@ fn lessThanByDisplayOrder(ctx: SortContext, lhs: usize, rhs: usize) bool {
 fn planSortRank(plan: ?registry.PlanType) u8 {
     return switch (plan orelse .unknown) {
         .team, .business, .enterprise, .edu => 0,
-        .free, .plus, .pro => 1,
+        .free, .plus, .prolite, .pro => 1,
         else => 2,
     };
 }
 
 fn displayPlan(rec: *const registry.AccountRecord) []const u8 {
-    return if (registry.resolvePlan(rec)) |plan| @tagName(plan) else "-";
+    return if (registry.resolvePlan(rec)) |plan| registry.planLabel(plan) else "-";
 }
 
 fn isActive(reg: *const registry.Registry, account_idx: usize) bool {

src/format.zig

@@ -19,7 +19,7 @@ fn colorEnabled() bool {
 }
 
 fn planDisplay(rec: *const registry.AccountRecord, missing: []const u8) []const u8 {
-    if (registry.resolvePlan(rec)) |p| return @tagName(p);
+    if (registry.resolvePlan(rec)) |p| return registry.planLabel(p);
     return missing;
 }
 
@@ -683,5 +683,5 @@ test "writeAccountsTable shows zero-padded row numbers for selectable accounts"
 
     const output = writer.buffered();
     try std.testing.expect(std.mem.indexOf(u8, output, "01   Als's Workspace") != null);
-    try std.testing.expect(std.mem.indexOf(u8, output, "02   free") != null);
+    try std.testing.expect(std.mem.indexOf(u8, output, "02   Free") != null);
 }

src/registry.zig

@@ -5,7 +5,7 @@ const c_time = @cImport({
     @cInclude("time.h");
 });
 
-pub const PlanType = enum { free, plus, pro, team, business, enterprise, edu, unknown };
+pub const PlanType = enum { free, plus, prolite, pro, team, business, enterprise, edu, unknown };
 pub const AuthMode = enum { chatgpt, apikey };
 pub const current_schema_version: u32 = 3;
 pub const min_supported_schema_version: u32 = 2;
@@ -84,6 +84,20 @@ pub fn resolvePlan(rec: *const AccountRecord) ?PlanType {
     return null;
 }
 
+pub fn planLabel(plan: PlanType) []const u8 {
+    return switch (plan) {
+        .free => "Free",
+        .plus => "Plus",
+        .prolite => "Pro Lite",
+        .pro => "Pro",
+        .team => "Team",
+        .business => "Business",
+        .enterprise => "Enterprise",
+        .edu => "Edu",
+        .unknown => "Unknown",
+    };
+}
+
 pub const Registry = struct {
     schema_version: u32,
     active_account_key: ?[]u8,
@@ -2512,6 +2526,7 @@ const RegistryOut = struct {
 fn parsePlanType(s: []const u8) ?PlanType {
     if (std.mem.eql(u8, s, "free")) return .free;
     if (std.mem.eql(u8, s, "plus")) return .plus;
+    if (std.mem.eql(u8, s, "prolite")) return .prolite;
     if (std.mem.eql(u8, s, "pro")) return .pro;
     if (std.mem.eql(u8, s, "team")) return .team;
     if (std.mem.eql(u8, s, "business")) return .business;

src/sessions.zig

@@ -450,6 +450,7 @@ fn parseCredits(allocator: std.mem.Allocator, parsed: UsageCreditsJson) registry
 fn parsePlanType(s: []const u8) registry.PlanType {
     if (std.ascii.eqlIgnoreCase(s, "free")) return .free;
     if (std.ascii.eqlIgnoreCase(s, "plus")) return .plus;
+    if (std.ascii.eqlIgnoreCase(s, "prolite")) return .prolite;
     if (std.ascii.eqlIgnoreCase(s, "pro")) return .pro;
     if (std.ascii.eqlIgnoreCase(s, "team")) return .team;
     if (std.ascii.eqlIgnoreCase(s, "business")) return .business;

src/tests/display_rows_test.zig

@@ -57,10 +57,10 @@ test "Scenario: Given same email with two team accounts and one plus account whe
     try std.testing.expect(rows.rows.len == 4);
     try std.testing.expect(rows.rows[0].account_index == null);
     try std.testing.expect(std.mem.eql(u8, rows.rows[0].account_cell, "user@example.com"));
-    try std.testing.expect(std.mem.eql(u8, rows.rows[1].account_cell, "team #1"));
+    try std.testing.expect(std.mem.eql(u8, rows.rows[1].account_cell, "Team #1"));
     try std.testing.expect(rows.rows[1].is_active);
-    try std.testing.expect(std.mem.eql(u8, rows.rows[2].account_cell, "team #2"));
-    try std.testing.expect(std.mem.eql(u8, rows.rows[3].account_cell, "plus"));
+    try std.testing.expect(std.mem.eql(u8, rows.rows[2].account_cell, "Team #2"));
+    try std.testing.expect(std.mem.eql(u8, rows.rows[3].account_cell, "Plus"));
     try std.testing.expect(rows.selectable_row_indices.len == 3);
 }
 
@@ -80,6 +80,23 @@ test "Scenario: Given grouped accounts with aliases when building display rows t
     try std.testing.expect(std.mem.eql(u8, rows.rows[2].account_cell, "backup") or std.mem.eql(u8, rows.rows[2].account_cell, "work"));
 }
 
+test "Scenario: Given grouped accounts with a prolite record when building display rows then labels use Pro Lite wording" {
+    const gpa = std.testing.allocator;
+    var reg = makeRegistry();
+    defer reg.deinit(gpa);
+
+    try appendAccount(gpa, &reg, "user-ESYgcy2QkOGZc0NoxSlFCeVT::67fe2bbb-0de6-49a4-b2b3-d1df366d1faf", "user@example.com", "", .prolite);
+    try appendAccount(gpa, &reg, "user-ESYgcy2QkOGZc0NoxSlFCeVT::518a44d9-ba75-4bad-87e5-ae9377042960", "user@example.com", "", .team);
+
+    var rows = try display_rows.buildDisplayRows(gpa, &reg, null);
+    defer rows.deinit(gpa);
+
+    try std.testing.expectEqual(@as(usize, 3), rows.rows.len);
+    try std.testing.expect(std.mem.eql(u8, rows.rows[0].account_cell, "user@example.com"));
+    try std.testing.expect(std.mem.eql(u8, rows.rows[1].account_cell, "Team"));
+    try std.testing.expect(std.mem.eql(u8, rows.rows[2].account_cell, "Pro Lite"));
+}
+
 test "Scenario: Given same-email accounts filtered down to one row when building display rows then singleton is decided from the rendered subset" {
     const gpa = std.testing.allocator;
     var reg = makeRegistry();
@@ -144,7 +161,7 @@ test "Scenario: Given mixed singleton and grouped accounts when building display
     try std.testing.expect(rows.rows[1].account_index == null);
     try std.testing.expect(std.mem.eql(u8, rows.rows[1].account_cell, "user@example.com"));
     try std.testing.expect(std.mem.eql(u8, rows.rows[2].account_cell, "work (Primary Workspace)"));
-    try std.testing.expect(std.mem.eql(u8, rows.rows[3].account_cell, "plus"));
+    try std.testing.expect(std.mem.eql(u8, rows.rows[3].account_cell, "Plus"));
 }
 
 test "Scenario: Given grouped accounts with account names when building display rows then child labels use the same precedence" {
@@ -168,5 +185,5 @@ test "Scenario: Given grouped accounts with account names when building display
             (std.mem.eql(u8, rows.rows[1].account_cell, "Backup Workspace") and
                 std.mem.eql(u8, rows.rows[2].account_cell, "work (Primary Workspace)")),
     );
-    try std.testing.expect(std.mem.eql(u8, rows.rows[3].account_cell, "plus"));
+    try std.testing.expect(std.mem.eql(u8, rows.rows[3].account_cell, "Plus"));
 }

src/tests/registry_test.zig

@@ -218,6 +218,34 @@ test "registry save/load" {
     try std.testing.expect(loaded.accounts.items[0].account_name == null);
 }
 
+test "plan labels are human-readable while registry stores raw plan values" {
+    const gpa = std.testing.allocator;
+    var tmp = std.testing.tmpDir(.{});
+    defer tmp.cleanup();
+
+    const codex_home = try tmp.dir.realpathAlloc(gpa, ".");
+    defer gpa.free(codex_home);
+    try tmp.dir.makePath("accounts");
+
+    var reg = makeEmptyRegistry();
+    defer reg.deinit(gpa);
+
+    try reg.accounts.append(gpa, try makeAccountRecord(gpa, "label@example.com", "", .prolite, .chatgpt, 1));
+    try registry.saveRegistry(gpa, codex_home, &reg);
+
+    const registry_path = try std.fs.path.join(gpa, &[_][]const u8{ codex_home, "accounts", "registry.json" });
+    defer gpa.free(registry_path);
+    const saved = try bdd.readFileAlloc(gpa, registry_path);
+    defer gpa.free(saved);
+
+    try std.testing.expect(std.mem.indexOf(u8, saved, "\"plan\": \"prolite\"") != null);
+    try std.testing.expect(std.mem.indexOf(u8, saved, "Pro Lite") == null);
+    try std.testing.expectEqualStrings("Free", registry.planLabel(.free));
+    try std.testing.expectEqualStrings("Plus", registry.planLabel(.plus));
+    try std.testing.expectEqualStrings("Pro Lite", registry.planLabel(.prolite));
+    try std.testing.expectEqualStrings("Team", registry.planLabel(.team));
+}
+
 test "registry load defaults missing account_name field to null" {
     const gpa = std.testing.allocator;
     var tmp = std.testing.tmpDir(.{});