pig-claude-bridge 0.1.0 → 0.3.0

package/README.md

@@ -10,9 +10,11 @@ A native Go extension for [PiG](https://github.com/MichaelKinsy/PiG) that integr
 ## Install
 
 ```sh
-pig install git:github.com/balcsida/pig-claude-bridge
+pig install npm:pig-claude-bridge
 ```
 
+Update it with `pig update npm:pig-claude-bridge`. To follow `main` instead of releases, install `git:github.com/balcsida/pig-claude-bridge`.
+
 Requirements:
 
 - PiG 0.5.3 or newer.
@@ -30,7 +32,19 @@ Behind the scenes, PiG's tools are bridged to Claude Code but everything works l
 
 The model list is a static table generated from the Anthropic catalog of `@earendil-works/pi-ai` 1.2.0 (`scripts/dev/gen-catalog.mjs`) and registered when the extension loads; it does not follow later catalog updates. Dated snapshot ids are not shown. See [docs/compatibility.md](docs/compatibility.md) (D5).
 
-**1M context:** Fable 5/5.1, Opus 5.5/5/4.8/4.7, and Sonnet 5.5/5 get 1M context. Opus 4.6 gets 1M only on a Max plan or with Extra Usage, and Sonnet 4.6 only with Extra Usage: set `provider.plan` and/or `provider.longContextExtraUsage` as described in [Configuration](#configuration).
+**1M context:** Fable 5/5.1, Opus 5.5/5/4.8/4.7, and Sonnet 5.5/5 get 1M context. Opus 4.6 gets 1M on Max, Ultra, Team (Standard and Premium seats) and Enterprise plans or with Extra Usage, and Sonnet 4.6 only with Extra Usage ([Claude Code docs](https://code.claude.com/docs/en/model-config#extended-context)): the extension detects the plan by itself (see `provider.plan` in [Configuration](#configuration)); set `provider.longContextExtraUsage` for Extra Usage.
+
+**Fast mode:** `/claude-fast` turns Claude Code's fast mode on or off for the rest of the session (`/claude-fast on`, `/claude-fast off`, or no argument to toggle); set `provider.fastMode` to `true` to start every session with it on. It takes effect from the next turn, on models that have fast mode (Opus 5.5, for example); other models ignore it. On subscription plans fast mode is billed to usage credits, not to the plan's limits, and on Team and Enterprise an Owner has to enable it for the organization first ([Claude Code docs](https://code.claude.com/docs/en/fast-mode)). While it is on, the footer shows `fast` (see [Footer status](#footer-status)).
+
+### Footer status
+
+The bridge keeps one entry in PiG's footer status bar, for example `Claude Max · fast · 5h 6% ↻3h · 7d 76% ↻8h · Fable 99% ↻8h`:
+
+- the plan (`Pro`, `Max`, `Ultra`, `Team`, `Enterprise`), when `provider.plan` is set or the plan was detected; nothing when it is unknown.
+- `fast` while fast mode is on; nothing when it is off.
+- the plan's usage limits, once Claude Code reports them (see [Plan usage for footers and quota extensions](#plan-usage-for-footers-and-quota-extensions)).
+
+The plan shows from session start, fast mode as soon as `/claude-fast` changes it, and the usage after the first turn.
 
 ## AskClaude Tool
 
@@ -55,6 +69,7 @@ The extension asks PiG for both directories; nothing is hard-coded. A missing or
   },
   "provider": {
     "plan": "max",
+    "fastMode": false,
     "longContextExtraUsage": false,
     "strictMcpConfig": true,
     "pathToClaudeCodeExecutable": "/home/you/.nix-profile/bin/claude"
@@ -73,14 +88,15 @@ The extension asks PiG for both directories; nothing is hard-coded. A missing or
 - `appendSkills`: forward PiG's skills block into the system prompt (default `true`)
 
 `provider`:
-- `plan` (default `"pro"`): set to `"max"` if you have a Max (or Team Premium/Enterprise) Anthropic plan. This enables Opus with 1M context.
+- `plan`: `"pro"`, `"max"`, `"ultra"`, `"team"` or `"enterprise"`. Every plan except `"pro"` enables Opus 4.6 with 1M context. Unset, the extension asks `claude auth status --json` once at load and uses the subscription it reports; when that fails (no `claude` on `PATH`, not logged in, or an API key login) it falls back to `"pro"`.
+- `fastMode` (default `false`): start every session with Claude Code's fast mode on. `/claude-fast` changes it for the current session.
 - `longContextExtraUsage`: set to `true` to enable 1M context models even if they cost money through Extra Usage on your plan. It enables Sonnet 4.6 with 1M on every plan and Opus 4.6 with 1M on Pro.
 - `forceTwoHundredK`: array of model ids to pin to 200K context (bare id, no `[1m]` suffix). Use if the catalog declares a model at 1M but Claude Code won't serve it on your plan.
 - `strictMcpConfig`: block MCP servers from `~/.claude.json` / `.mcp.json` (default `true`). Cloud MCP (Gmail/Drive via claude.ai OAuth) is always blocked.
 - `autoMemoryEnabled`: enable Claude Code's auto-memory system (default `false`)
 - `pathToClaudeCodeExecutable`: path to the `claude` binary, used instead of the one on `PATH`. A path ending in `.js`, `.mjs` or `.ts` is run through `node`, as the Agent SDK does.
 
-**Notices:** the startup notice, shown at the first bridge turn in the TUI only (it stays pending in RPC, JSON and print mode), points out when `provider.plan` is unset and records `startupNoticeShown` (a date) in the global config. A deprecation notice on first use of AskClaude records its display date as `askClaudeDeprecationShown`. The extension rewrites the global file only to add these keys and leaves every other key as it was; an unparseable global file is left alone.
+**Notices:** the startup notice, shown at the first bridge turn in the TUI only (it stays pending in RPC, JSON and print mode), points out when `provider.plan` is unset and was not detected, and records `startupNoticeShown` (a date) in the global config. A deprecation notice on first use of AskClaude records its display date as `askClaudeDeprecationShown`. The extension rewrites the global file only to add these keys and leaves every other key as it was; an unparseable global file is left alone.
 
 ## Why Go
 
@@ -164,7 +180,7 @@ PiG runs compaction and branch summaries natively. The bridge routes their `cach
 
 ### Plan usage for footers and quota extensions
 
-Claude Code sends a `rate_limit_event` when a usage window changes. The TypeScript bridge passes it to Pi's `after_provider_response` event as `anthropic-ratelimit-unified-*` headers. PiG's host does not emit that event, so this port writes the headers to the debug log only; the user-visible rate-limit notices stay. This is difference D1 in [docs/compatibility.md](docs/compatibility.md).
+Claude Code sends a `rate_limit_event` when a usage window changes. The TypeScript bridge passes it to Pi's `after_provider_response` event as `anthropic-ratelimit-unified-*` headers. PiG's host does not emit that event, so this port writes the headers to the debug log only; the user-visible rate-limit notices stay. The bridge also shows the plan's limits in PiG's footer status bar, after the plan and fast mode (see [Footer status](#footer-status)), for example `Claude Max · 5h 6% ↻3h · 7d 76% ↻8h · Fable 99% ↻8h · reset available`. On each event it asks Claude Code for its `/usage` rows (`get_usage`), which name per-model limits; when that fails it shows the event's own windows. This is difference D1 in [docs/compatibility.md](docs/compatibility.md).
 
 ## Known issues
 

package/extensions/pig-claude-bridge/extension.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"strings"
 	"time"
 
 	sdk "github.com/MichaelKinsy/PiG/extensions/sdk"
@@ -26,6 +27,18 @@ func (h sdkHost) Notify(message, level string) {
 	h.ctx.Notify(message, level)
 }
 
+// SetStatus drops the status if the context is stale, as Notify does.
+func (h sdkHost) SetStatus(key, text string) {
+	defer func() { _ = recover() }()
+	h.ctx.SetStatus(key, text)
+}
+
+// ClearStatus drops the call if the context is stale, as SetStatus does.
+func (h sdkHost) ClearStatus(key string) {
+	defer func() { _ = recover() }()
+	h.ctx.ClearStatus(key)
+}
+
 func (h sdkHost) SessionID() (string, error) { return h.ctx.SessionManager().GetSessionID() }
 func (h sdkHost) Cwd() string                { return h.ctx.Cwd() }
 
@@ -118,6 +131,17 @@ func Extension() *sdk.Extension {
 	configDirName, _ := sdk.ConfigDirName()
 	cwd, _ := os.Getwd()
 	cfg := config.Load(agentDir, cwd, configDirName)
+	// Detected before the provider registers, since the plan decides which models get 1M.
+	// Skipped outside a host, so validate-only installs and tests never spawn claude.
+	if agentDir != "" && cfg.Provider.Plan == nil {
+		plan, err := bridge.DetectPlan(context.Background(), cfg.Provider)
+		if err != nil {
+			cfg.Problems = append(cfg.Problems, fmt.Sprintf("claude-bridge: plan detection failed: %v", err))
+		}
+		if plan != "" {
+			cfg.Provider.Plan = &plan
+		}
+	}
 	b := bridge.New(bridge.Deps{
 		Config:        cfg,
 		AgentDir:      agentDir,
@@ -144,6 +168,26 @@ func Extension() *sdk.Extension {
 		"streamSimple": sdk.ProviderStreamSimpleFunc(streamSimple),
 	})
 
+	ext.Command("claude-fast", "Toggle Claude Code fast mode for this session (on|off)", func(ctx sdk.Context, args string) error {
+		host := sdkHost{ctx}
+		switch strings.TrimSpace(args) {
+		case "":
+			b.SetFastMode(host, !b.FastMode())
+		case "on":
+			b.SetFastMode(host, true)
+		case "off":
+			b.SetFastMode(host, false)
+		default:
+			return fmt.Errorf("usage: /claude-fast [on|off]")
+		}
+		state := "off"
+		if b.FastMode() {
+			state = "on (from the next turn, on models that support it)"
+		}
+		host.Notify("Claude fast mode "+state, "info")
+		return nil
+	})
+
 	if a := cfg.AskClaude; a != nil && a.Enabled != nil && *a.Enabled {
 		ext.RegisterTool(askclaude.Definition(b, cfg, agentDir,
 			func(ctx sdk.Context) bridge.Host { return sdkHost{ctx} }, requestContext))

package/extensions/pig-claude-bridge/internal/bridge/askclaude.go

@@ -117,6 +117,7 @@ func (b *Bridge) PromptAndWait(ctx context.Context, host Host, r AskRequest) (te
 	// the skills block, the only channel. The preset prompt is unconditional: without it
 	// the child lacks the tool and permission guidance the bridge relies on.
 	settings := config.ClaudeCodeSettings(b.deps.Config.Provider)
+	b.applyFastMode(settings)
 	settings["claudeMdExcludes"] = claudeMdExcludes
 	debugFile, onStderr := b.cliDebugOptions("askclaude")
 	opts := ccproto.Options{

package/extensions/pig-claude-bridge/internal/bridge/hooks.go

@@ -121,6 +121,7 @@ func (b *Bridge) hostSessionID(host Host, event string) string {
 // session is a fresh conversation.
 func (b *Bridge) OnSessionStart(host Host, reason string) {
 	defer b.recoverHandler("session_start")
+	b.showStatus(host)
 	b.rememberSessionCwd(b.hostSessionID(host, "session_start"), host.Cwd())
 	switch reason {
 	case "new", "resume", "fork":

package/extensions/pig-claude-bridge/internal/bridge/host.go

@@ -71,6 +71,12 @@ type Bridge struct {
 	// captures is the prompt-capture registry, guarded by its own mutex.
 	captures    *promptcapture.Captures
 	longContext models.LongContextSettings
+	// fastMode adds fastMode to Claude Code's --settings; /claude-fast flips it mid-session.
+	fastMode atomic.Bool
+	// plan is provider.plan as configured or detected, "" when unknown; the footer shows it.
+	plan string
+	// lastUsage is the usage windows the footer last showed, guarded by mu.
+	lastUsage string
 
 	// queries tracks the goroutines a provider call starts, so a shutdown or a test
 	// can wait for them.
@@ -95,6 +101,12 @@ func New(d Deps) *Bridge {
 		cwds:             map[string]string{},
 		longContext:      LongContextSettings(d.Config.Provider),
 	}
+	if p := d.Config.Provider; p != nil && p.FastMode != nil {
+		b.fastMode.Store(*p.FastMode)
+	}
+	if p := d.Config.Provider; p != nil && p.Plan != nil {
+		b.plan = *p.Plan
+	}
 	b.captures = promptcapture.NewCaptures(0, b.debugCaptureMiss)
 	b.queueStartupNotices()
 	for _, p := range d.Config.Problems {

package/extensions/pig-claude-bridge/internal/bridge/notices.go

@@ -1,9 +1,11 @@
 package bridge
 
 import (
+	"context"
 	"fmt"
 	"strings"
 
+	"github.com/balcsida/pig-claude-bridge/extensions/pig-claude-bridge/internal/ccproto"
 	"github.com/balcsida/pig-claude-bridge/extensions/pig-claude-bridge/internal/config"
 	"github.com/balcsida/pig-claude-bridge/extensions/pig-claude-bridge/internal/models"
 	"github.com/balcsida/pig-claude-bridge/extensions/pig-claude-bridge/internal/promptcapture"
@@ -102,6 +104,44 @@ func LongContextSettings(p *config.ProviderConfig) models.LongContextSettings {
 	return s
 }
 
+// DetectPlan asks Claude Code for the subscription behind its login, for when provider.plan
+// is unset. A subscription the 1M rules don't know is not returned, so the notice still asks.
+func DetectPlan(ctx context.Context, p *config.ProviderConfig) (string, error) {
+	configured := ""
+	if p != nil && p.PathToClaudeCodeExecutable != nil {
+		configured = *p.PathToClaudeCodeExecutable
+	}
+	exe, err := ccproto.ResolveExecutable(configured)
+	if err != nil {
+		return "", err
+	}
+	sub, err := ccproto.SubscriptionType(ctx, exe)
+	switch sub {
+	case "pro", "max", "ultra", "team", "enterprise":
+		return sub, err
+	}
+	return "", err
+}
+
+// SetFastMode turns Claude Code's fast mode on or off from the next turn on and updates
+// host's footer; each turn spawns a fresh Claude Code, so a live query keeps the mode it
+// started with.
+func (b *Bridge) SetFastMode(host Host, on bool) {
+	b.fastMode.Store(on)
+	b.showStatus(host)
+}
+
+// FastMode reports whether the next turn asks Claude Code for fast mode.
+func (b *Bridge) FastMode() bool { return b.fastMode.Load() }
+
+// applyFastMode opts settings into fast mode. Claude Code under the SDK keeps fast mode off
+// (sdk_opt_in_required) unless --settings carries fastMode; a model without fast mode ignores it.
+func (b *Bridge) applyFastMode(settings map[string]any) {
+	if b.fastMode.Load() {
+		settings["fastMode"] = true
+	}
+}
+
 // reasoningToEffort maps pi reasoning levels to Claude Code effort levels.
 var reasoningToEffort = map[string]string{
 	"minimal": "low", "low": "low", "medium": "medium", "high": "high", "xhigh": "max", "max": "max",

package/extensions/pig-claude-bridge/internal/bridge/provider.go

@@ -347,6 +347,7 @@ func (b *Bridge) freshQuery(ctx context.Context, host Host, stream *sdk.ModelEve
 	settings := config.ClaudeCodeSettings(providerSettings)
 	settings["claudeMdExcludes"] = claudeMdExcludes
 	settings["includeGitInstructions"] = false
+	b.applyFastMode(settings)
 	debugFile, onStderr := b.cliDebugOptions("provider")
 	opts := ccproto.Options{
 		Executable: exe, Cwd: cwd, Effort: effort, Resume: syncResult.SessionID,

package/extensions/pig-claude-bridge/internal/bridge/ratelimit.go

@@ -1,12 +1,17 @@
 package bridge
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
+	"maps"
 	"math"
+	"slices"
 	"strconv"
 	"strings"
 	"time"
+
+	"github.com/balcsida/pig-claude-bridge/extensions/pig-claude-bridge/internal/ccproto"
 )
 
 const rateLimitHeaderPrefix = "anthropic-ratelimit-unified"
@@ -199,6 +204,189 @@ func (b *Bridge) handleRateLimitEvent(host Host, q *QueryContext, info RateLimit
 	if notice != "" && host != nil { // the TypeScript's piUI?.notify
 		host.Notify(notice, "warning")
 	}
+	q.mu.Lock()
+	client := q.activeQuery
+	q.mu.Unlock()
+	b.showUsage(host, client, info.UnifiedWindows)
+}
+
+// showUsage puts the plan's usage in the footer status. The event's windows lack the
+// per-model limits' names, so it asks the live CLI for its /usage rows and falls back
+// to the windows when there is no client or the CLI does not answer. An empty usage
+// keeps the last one shown.
+func (b *Bridge) showUsage(host Host, client ccproto.Client, windows map[string]*UsageWindow) {
+	if _, ok := host.(StatusSetter); !ok {
+		return
+	}
+	set := func(usage string) {
+		if usage != "" {
+			b.mu.Lock()
+			b.lastUsage = usage
+			b.mu.Unlock()
+			b.showStatus(host)
+		}
+	}
+	if client == nil {
+		set(usageStatus(windows, b.deps.Now()))
+		return
+	}
+	b.queries.Add(1)
+	go func() {
+		defer b.queries.Done()
+		ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+		defer cancel()
+		reply, err := client.Usage(ctx)
+		status := planUsageStatus(reply, b.deps.Now())
+		if err != nil || status == "" {
+			b.debugf("rate limit: get_usage unusable (%v), showing the event's windows", err)
+			status = usageStatus(windows, b.deps.Now())
+		}
+		set(status)
+	}()
+}
+
+// UsageStatusKey is the footer status entry that shows the plan, fast mode and usage windows.
+const UsageStatusKey = "claude-usage"
+
+// StatusSetter is a Host that can show a footer status; hosts without one skip it.
+type StatusSetter interface {
+	SetStatus(key, text string)
+	ClearStatus(key string)
+}
+
+// showStatus renders the footer entry as "Claude Max · fast · 5h 6% ↻3h · 7d 76% ↻8h": the
+// plan when configured or detected, "fast" while fast mode is on, then the last usage
+// windows. With none of the three the entry is removed.
+func (b *Bridge) showStatus(host any) {
+	s, ok := host.(StatusSetter)
+	if !ok {
+		return
+	}
+	var parts []string
+	if b.plan != "" {
+		parts = append(parts, strings.ToUpper(b.plan[:1])+b.plan[1:])
+	}
+	if b.fastMode.Load() {
+		parts = append(parts, "fast")
+	}
+	b.mu.Lock()
+	if b.lastUsage != "" {
+		parts = append(parts, b.lastUsage)
+	}
+	b.mu.Unlock()
+	if len(parts) == 0 {
+		s.ClearStatus(UsageStatusKey)
+		return
+	}
+	s.SetStatus(UsageStatusKey, "Claude "+strings.Join(parts, " · "))
+}
+
+// usageStatus renders the unified windows as "5h 14% ↻3h · 7d 1% ↻2d", or ""
+// when no window carries a utilization.
+func usageStatus(windows map[string]*UsageWindow, now time.Time) string {
+	var parts []string
+	for _, name := range slices.Sorted(maps.Keys(windows)) {
+		w := windows[name]
+		if w == nil || w.Utilization == nil {
+			continue
+		}
+		label, ok := windowAbbreviations[name]
+		if !ok {
+			label = name
+		}
+		var resetsAt time.Time
+		if w.ResetsAt != nil {
+			resetsAt = time.Unix(int64(*w.ResetsAt), 0)
+		}
+		parts = append(parts, fmt.Sprintf("%s %d%%", label, int(math.Floor(*w.Utilization*100+0.5)))+resetsIn(resetsAt, now))
+	}
+	return strings.Join(parts, " · ")
+}
+
+// resetsIn is " ↻3h": the time to a window's reset, floored to its largest unit as the
+// Claude app shows it, or "" when the reset is unknown or past.
+func resetsIn(at, now time.Time) string {
+	d := at.Sub(now)
+	switch {
+	case at.IsZero() || d <= 0:
+		return ""
+	case d < time.Hour:
+		return fmt.Sprintf(" ↻%dm", max(1, int(d/time.Minute)))
+	case d < 24*time.Hour:
+		return fmt.Sprintf(" ↻%dh", int(d/time.Hour))
+	}
+	return fmt.Sprintf(" ↻%dd", int(d/(24*time.Hour)))
+}
+
+// usageWindow is one keyed limit of a get_usage reply; utilization is a percentage.
+type usageWindow struct {
+	DisplayName string    `json:"display_name"`
+	Utilization float64   `json:"utilization"`
+	ResetsAt    time.Time `json:"resets_at"`
+}
+
+// usageReply is the part of a get_usage reply the footer reads. It reads the keyed
+// windows, not the labelled limits[] rows, which the server sometimes leaves out.
+type usageReply struct {
+	RateLimits *struct {
+		FiveHour    *usageWindow  `json:"five_hour"`
+		SevenDay    *usageWindow  `json:"seven_day"`
+		ModelScoped []usageWindow `json:"model_scoped"`
+		CedarEmber  any           `json:"cedar_ember"`
+	} `json:"rate_limits"`
+}
+
+// planUsageStatus renders a get_usage reply as
+// "5h 6% ↻3h · 7d 76% ↻8h · Fable 99% ↻8h", plus "reset available" when the
+// account holds an unused rate-limit reset. "" when the reply has no windows.
+func planUsageStatus(raw json.RawMessage, now time.Time) string {
+	var r usageReply
+	if json.Unmarshal(raw, &r) != nil || r.RateLimits == nil {
+		return ""
+	}
+	var parts []string
+	add := func(label string, w *usageWindow) {
+		if w != nil && label != "" {
+			parts = append(parts, fmt.Sprintf("%s %d%%", label, int(math.Round(w.Utilization)))+resetsIn(w.ResetsAt, now))
+		}
+	}
+	add("5h", r.RateLimits.FiveHour)
+	add("7d", r.RateLimits.SevenDay)
+	for i := range r.RateLimits.ModelScoped {
+		add(r.RateLimits.ModelScoped[i].DisplayName, &r.RateLimits.ModelScoped[i])
+	}
+	if len(parts) == 0 {
+		return ""
+	}
+	if holdsUnusedReset(r.RateLimits.CedarEmber) {
+		parts = append(parts, "reset available")
+	}
+	return strings.Join(parts, " · ")
+}
+
+// holdsUnusedReset reports whether the usage reply's cedar_ember block (the reset
+// grants /reset_rate_limits claims) holds a grant with resets left.
+// shortcut: the nesting of grants in the block is unobserved (it was null on the probed
+// account), so any resets_left above 0 counts; pin it once a live reply carries a grant.
+func holdsUnusedReset(v any) bool {
+	switch v := v.(type) {
+	case map[string]any:
+		if n, ok := v["resets_left"].(float64); ok && n > 0 {
+			return true
+		}
+		for _, child := range v {
+			if holdsUnusedReset(child) {
+				return true
+			}
+		}
+	case []any:
+		for _, child := range v {
+			if holdsUnusedReset(child) {
+				return true
+			}
+		}
+	}
+	return false
 }
 
 func sameFloat(a, b *float64) bool {

package/extensions/pig-claude-bridge/internal/ccproto/control.go

@@ -124,6 +124,12 @@ func (p *Process) Interrupt(ctx context.Context) (json.RawMessage, error) {
 	return p.request(ctx, map[string]any{"subtype": "interrupt", "cancel_queued": true})
 }
 
+// Usage sends get_usage and returns the raw /usage payload: the plan's labelled limit rows, among others.
+// skip_behaviors skips the CLI's scan of local transcripts, which a usage meter does not need.
+func (p *Process) Usage(ctx context.Context) (json.RawMessage, error) {
+	return p.request(ctx, map[string]any{"subtype": "get_usage", "skip_behaviors": true})
+}
+
 func (p *Process) sendSuccess(id string, payload any) {
 	_ = p.writeJSON(map[string]any{"type": "control_response", "response": map[string]any{
 		"subtype": "success", "request_id": id, "response": payload}})

package/extensions/pig-claude-bridge/internal/ccproto/exec.go

@@ -4,6 +4,8 @@ package ccproto
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
 	"fmt"
 	"os/exec"
 	"path/filepath"
@@ -75,6 +77,31 @@ func Version(ctx context.Context, exe string) (string, error) {
 	return m[1], nil
 }
 
+// AuthStatusTimeout bounds `claude auth status`: it runs while the extension loads, which must not hang.
+var AuthStatusTimeout = 5 * time.Second
+
+// SubscriptionType runs `<exe> auth status --json` and returns its subscriptionType ("pro", "max",
+// "team", "enterprise"); "" when the login is not a Claude subscription.
+func SubscriptionType(ctx context.Context, exe string) (string, error) {
+	probe, cancel := context.WithTimeout(ctx, AuthStatusTimeout)
+	defer cancel()
+	name, args, err := commandLine(exe, "auth", "status", "--json")
+	if err != nil {
+		return "", err
+	}
+	cmd := exec.CommandContext(probe, name, args...)
+	cmd.WaitDelay = time.Second
+	// Logged out exits non-zero but still prints the JSON, so the output decides.
+	out, runErr := cmd.Output()
+	var status struct {
+		SubscriptionType string `json:"subscriptionType"`
+	}
+	if err := json.Unmarshal(out, &status); err != nil {
+		return "", fmt.Errorf("run %s auth status --json: %v (output %q)", exe, errors.Join(runErr, err), strings.TrimSpace(string(out)))
+	}
+	return status.SubscriptionType, nil
+}
+
 // OlderThan reports whether version is numerically older than minimum; unparsable input is not older.
 func OlderThan(version, minimum string) bool {
 	a, okA := parseSemver(version)

package/extensions/pig-claude-bridge/internal/ccproto/transport.go

@@ -39,6 +39,7 @@ type Client interface {
 	WriteUser(msg UserMessage) error
 	EndInput() error
 	Interrupt(ctx context.Context) (json.RawMessage, error)
+	Usage(ctx context.Context) (json.RawMessage, error)
 	Close(ctx context.Context) error
 	Wait() error
 	StderrTail() string

package/extensions/pig-claude-bridge/internal/config/config.go

@@ -43,8 +43,11 @@ type ProviderConfig struct {
 	StrictMcpConfig            *bool   `json:"strictMcpConfig,omitempty"`
 	AutoMemoryEnabled          *bool   `json:"autoMemoryEnabled,omitempty"`
 	PathToClaudeCodeExecutable *string `json:"pathToClaudeCodeExecutable,omitempty"`
-	// Plan is the subscription tier ("pro" | "max"). "max" enables Opus 4.6 at 1M context.
+	// Plan is the subscription tier ("pro" | "max" | "ultra" | "team" | "enterprise"). Every plan
+	// but "pro" enables Opus 4.6 at 1M context. Unset, the extension asks `claude auth status` at load.
 	Plan *string `json:"plan,omitempty"`
+	// FastMode starts every session with Claude Code's fast mode on; /claude-fast toggles it.
+	FastMode *bool `json:"fastMode,omitempty"`
 	// LongContextExtraUsage opts into metered 1M context usage. Enables Sonnet 4.6 [1m]
 	// on every plan and Opus 4.6 [1m] on Pro.
 	LongContextExtraUsage *bool `json:"longContextExtraUsage,omitempty"`

package/extensions/pig-claude-bridge/internal/models/models.go

@@ -18,7 +18,7 @@ const (
 
 // LongContextSettings carries the plan facts that decide whether a [1m] id is served.
 type LongContextSettings struct {
-	Plan                  string // "pro" or "max"
+	Plan                  string // "pro", "max", "ultra", "team" or "enterprise"
 	LongContextExtraUsage bool
 	// ForceTwoHundredK lists model ids whose declared 1M context Claude Code
 	// turned out not to serve; they stay on the bare id at 200K.
@@ -58,8 +58,11 @@ var measuredOneM = map[string]bool{
 // planGatedOneM holds the measured exceptions: pi-ai declares 1M and the [1m]
 // id works, but only when the plan allows it.
 var planGatedOneM = map[string]func(LongContextSettings) bool{
-	// [1m] measured 1M on Max plan / extra usage; 429 on Pro without it.
-	"claude-opus-4-6": func(s LongContextSettings) bool { return s.Plan == "max" || s.LongContextExtraUsage },
+	// [1m] measured 1M on Max plan / extra usage; 429 on Pro without it. Max, Ultra, Team (Standard
+	// and Premium) and Enterprise include it, per code.claude.com/docs/en/model-config#extended-context.
+	"claude-opus-4-6": func(s LongContextSettings) bool {
+		return slices.Contains([]string{"max", "ultra", "team", "enterprise"}, s.Plan) || s.LongContextExtraUsage
+	},
 	// [1m] measured 1M with extra usage only.
 	"claude-sonnet-4-6": func(s LongContextSettings) bool { return s.LongContextExtraUsage },
 }

package/package.json

@@ -1 +1 @@
-{"name":"pig-claude-bridge","version":"0.1.0","license":"MIT","repository":{"type":"git","url":"git+https://github.com/balcsida/pig-claude-bridge.git"},"files":["extensions","!**/*_test.go","!**/testdata","docs/compatibility.md","UPSTREAM.md","THIRD_PARTY_NOTICES.md","SECURITY.md"],"keywords":["pig-package"],"pi":{"extensions":["extensions/pig-claude-bridge"]}}
+{"name":"pig-claude-bridge","version":"0.3.0","description":"Claude Code in PiG: Claude models as a provider and an AskClaude tool. A native Go port of pi-claude-bridge.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/balcsida/pig-claude-bridge.git"},"files":["extensions","!**/*_test.go","!**/testdata","docs/compatibility.md","UPSTREAM.md","THIRD_PARTY_NOTICES.md","SECURITY.md"],"keywords":["pig-package"],"pi":{"extensions":["extensions/pig-claude-bridge"]}}