claude-code-superkit 0.0.0-stage → 1.5.3

package/packages/core/docs-templates/architecture/api-contracts.md

@@ -0,0 +1,26 @@
+# External API Contracts
+
+> Update when adding or changing external API integrations.
+
+## Integrations
+
+| Service | Purpose | Auth | Docs |
+|---------|---------|------|------|
+| TODO | TODO | TODO | TODO |
+
+## Request/Response Patterns
+
+<!-- For each external API, document: endpoint, auth, rate limits, error handling -->
+
+### TODO: Service Name
+
+- **Base URL:** TODO
+- **Auth:** TODO (API key, OAuth, etc.)
+- **Rate Limits:** TODO
+- **Error Handling:** TODO (retry? circuit breaker? fallback?)
+
+## Webhook Handling
+
+<!-- If you receive webhooks from external services -->
+
+TODO: Describe webhook endpoints and validation.

package/packages/core/docs-templates/architecture/api-reference.md

@@ -0,0 +1,48 @@
+# API Reference
+
+> Maintain this file when handlers or routes change. This is the source of truth for all endpoints.
+
+## Authentication
+
+<!-- Auth mechanism: JWT, API key, OAuth, session cookies?
+     Where is the token sent? (Authorization header, cookie, query param?) -->
+
+TODO: Describe auth mechanism.
+
+## Base URL
+
+TODO: e.g., `http://localhost:8080/api/v1`
+
+## Endpoints
+
+### Public (no auth required)
+
+| Method | Path | Description |
+|--------|------|-------------|
+| TODO | TODO | TODO |
+
+### Protected (auth required)
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| TODO | TODO | TODO | TODO |
+
+### Admin
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| TODO | TODO | TODO | TODO |
+
+## Error Response Format
+
+<!-- Standard error shape returned by all endpoints -->
+
+```json
+TODO: { "error": { "code": "...", "message": "..." } }
+```
+
+## Pagination
+
+<!-- How are list endpoints paginated? Cursor-based? Offset? -->
+
+TODO: Describe pagination pattern.

package/packages/core/docs-templates/architecture/auth-and-sessions.md

@@ -0,0 +1,38 @@
+# Authentication & Sessions
+
+> Update when auth flow, token format, or session management changes.
+
+## Auth Flow
+
+<!-- Describe the authentication flow step by step -->
+
+1. TODO: Client sends credentials (login form, OAuth, Telegram initData, etc.)
+2. TODO: Server validates → issues token (JWT, session cookie, API key)
+3. TODO: Client stores token (localStorage, cookie, memory)
+4. TODO: Client sends token with requests (Authorization header, cookie)
+5. TODO: Server validates token on each request (middleware)
+
+## Token Format
+
+<!-- JWT claims, expiration, refresh mechanism -->
+
+TODO: Describe token format and lifecycle.
+
+## Session Management
+
+<!-- How are sessions stored? Redis? DB? Memory?
+     Single-device enforcement? Session invalidation? -->
+
+TODO: Describe session storage and management.
+
+## Refresh Flow
+
+<!-- How are expired tokens refreshed? -->
+
+TODO: Describe refresh mechanism.
+
+## Permissions / RBAC
+
+<!-- Role-based access control, if any -->
+
+TODO: Describe roles and permissions.

package/packages/core/docs-templates/architecture/backend-layers.md

@@ -0,0 +1,42 @@
+# Backend Architecture — Layers
+
+> Fill in your backend's layered architecture. Update when adding new layers or changing DI patterns.
+
+## Layers
+
+<!-- Describe your layer hierarchy, e.g.:
+     Transport (HTTP handlers) → Services (business logic) → Repositories (data access)
+     State which layers can import which. -->
+
+TODO: Define your layers and their dependency rules.
+
+## Dependency Injection
+
+<!-- How are dependencies wired? Constructor injection? DI container? Service locator?
+     Show a typical constructor signature. -->
+
+TODO: Describe your DI pattern with example.
+
+## Error Handling
+
+<!-- How do errors propagate across layers?
+     Domain errors in services? Error wrapping with context? HTTP status mapping in handlers? -->
+
+TODO: Define error propagation strategy.
+
+## Middleware
+
+<!-- List middleware applied to routes: auth, CORS, logging, rate limiting, etc.
+     Which route groups get which middleware? -->
+
+TODO: List middleware stack.
+
+## Adding a New Endpoint (Checklist)
+
+<!-- Step-by-step for adding a new API endpoint in this architecture. -->
+
+1. TODO: Create handler in transport layer
+2. TODO: Create/update service with business logic
+3. TODO: Create/update repository if data access needed
+4. TODO: Register route with appropriate middleware
+5. TODO: Add tests

package/packages/core/docs-templates/architecture/data-flow.md

@@ -0,0 +1,26 @@
+# Key Data Flows
+
+> Update when major features change their data flow through the system.
+
+## Flow Template
+
+For each major feature, document the data flow:
+
+```
+[Trigger] → [Step 1] → [Step 2] → ... → [Result]
+```
+
+## TODO: Feature 1 Flow
+
+```
+TODO: User action → Handler → Service → Repo → DB → Response
+```
+
+**Key decisions:**
+- TODO: Why this flow? What alternatives were considered?
+
+## TODO: Feature 2 Flow
+
+```
+TODO: Describe another key data flow
+```

package/packages/core/docs-templates/architecture/database-schema.md

@@ -0,0 +1,51 @@
+# Database Schema
+
+> Update when migrations add/change tables, columns, indexes, or constraints.
+
+## Database
+
+- **Engine:** TODO (PostgreSQL 16, MySQL 8, SQLite, etc.)
+- **Driver:** TODO (pgx, prisma, sqlalchemy, diesel, etc.)
+- **ORM:** TODO (none/raw SQL, Prisma, GORM, SQLAlchemy, Diesel)
+
+## Tables
+
+<!-- List key tables with their purpose. Don't duplicate the migration files —
+     focus on relationships, constraints, and design decisions. -->
+
+| Table | Purpose | Key Columns |
+|-------|---------|-------------|
+| TODO | TODO | TODO |
+
+## Relationships
+
+<!-- Describe key FK relationships and ON DELETE behavior -->
+
+TODO: e.g., `orders.user_id → users.id ON DELETE CASCADE`
+
+## Indexes
+
+<!-- List important indexes and why they exist -->
+
+| Index | Table | Columns | Purpose |
+|-------|-------|---------|---------|
+| TODO | TODO | TODO | TODO |
+
+## Migrations
+
+- **Format:** TODO (e.g., `000NNN_description.up.sql` / `.down.sql`)
+- **Tool:** TODO (golang-migrate, dbmate, alembic, prisma, knex)
+- **Directory:** TODO (e.g., `backend/migrations/`)
+- **Current range:** TODO (e.g., 000001..000048)
+
+## Views
+
+<!-- SQL views used for reporting, dashboards, aggregations -->
+
+TODO: List views if any.
+
+## Conventions
+
+- TODO: Timestamps use TIMESTAMPTZ (not TIMESTAMP)
+- TODO: All tables have `created_at`, `updated_at`
+- TODO: Soft delete via `deleted_at` column (or hard delete)

package/packages/core/docs-templates/architecture/deployment.md

@@ -0,0 +1,41 @@
+# Deployment
+
+> Update when deploy process, environments, or infrastructure changes.
+
+## Environments
+
+| Environment | URL | Purpose |
+|------------|-----|---------|
+| TODO: local | localhost | Development |
+| TODO: staging | staging.example.com | Pre-production testing |
+| TODO: production | example.com | Live |
+
+## Infrastructure
+
+<!-- Docker, Kubernetes, VPS, serverless, PaaS? -->
+
+TODO: Describe infrastructure.
+
+## Deploy Process
+
+<!-- Step by step: how code goes from main branch to production -->
+
+1. TODO: Tests pass in CI
+2. TODO: Build artifacts
+3. TODO: Deploy to staging
+4. TODO: Smoke test
+5. TODO: Deploy to production
+
+## Environment Variables
+
+<!-- Key env vars needed per service -->
+
+| Variable | Service | Description |
+|----------|---------|-------------|
+| TODO | TODO | TODO |
+
+## Rollback
+
+<!-- How to rollback a bad deploy -->
+
+TODO: Describe rollback procedure.

package/packages/core/docs-templates/architecture/frontend-state.md

@@ -0,0 +1,46 @@
+# Frontend Architecture — State & Navigation
+
+> Update when state management, routing, or data fetching patterns change.
+
+## Tech Stack
+
+- **Framework:** TODO (React 19, Vue 3, Svelte 5, Next.js 15, etc.)
+- **State Management:** TODO (Zustand, Redux, Pinia, TanStack Query, etc.)
+- **Routing:** TODO (React Router, file-based, state-based, etc.)
+- **Styling:** TODO (Tailwind, CSS Modules, styled-components, etc.)
+- **Animations:** TODO (motion/react, GSAP, CSS transitions, etc.)
+
+## State Management
+
+<!-- Server state vs client state separation.
+     Which library handles which? -->
+
+TODO: Describe state management approach.
+
+## Data Fetching
+
+<!-- How is server data fetched and cached?
+     Stale times, cache invalidation, persistence? -->
+
+TODO: Describe data fetching patterns.
+
+## Navigation / Routing
+
+<!-- How do users navigate between screens?
+     URL-based? State-based? How is browser back handled? -->
+
+TODO: Describe routing approach.
+
+## Screen Map
+
+<!-- List all screens/pages with their routes/states -->
+
+| Screen | Route/State | Description |
+|--------|------------|-------------|
+| TODO | TODO | TODO |
+
+## Component Patterns
+
+<!-- Shared component conventions: naming, file structure, props patterns -->
+
+TODO: Describe component conventions.

package/packages/core/helpers/statusline.cjs

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+// statusline.cjs — Claude Code status bar for superkit
+// Shows: superkit version, git branch, model + effort (+ ⟁ULTRA badge),
+//        context bar, and real 5h/weekly rate-limit bars. Every segment fail-open.
+// Pure Node.js, no external dependencies, 2s timeout on all execSync calls
+
+'use strict';
+
+const { execSync } = require('child_process');
+const { existsSync, readFileSync, readdirSync, openSync, fstatSync, readSync, closeSync } = require('fs');
+const { join } = require('path');
+
+// ── Read optional JSON payload from stdin (non-blocking, 50ms window) ─────────
+// Claude Code 2.1.x may pass a richer status payload via stdin.
+// Older CLIs pass nothing — we must never block or throw on empty/TTY stdin.
+function readStdinPayload() {
+  try {
+    if (process.stdin.isTTY) return null;       // interactive terminal — skip
+    const buf = [];
+    // Read synchronously with a hard limit: if no data in fd, readSync throws
+    const fd = process.stdin.fd;
+    const chunk = Buffer.alloc(4096);
+    let total = Buffer.alloc(0);
+    let n;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      try {
+        n = require('fs').readSync(fd, chunk, 0, chunk.length, null);
+      } catch { break; }
+      if (n === 0) break;
+      total = Buffer.concat([total, chunk.slice(0, n)]);
+      if (total.length > 65536) break;  // guard against runaway
+    }
+    const text = total.toString('utf8').trim();
+    if (!text) return null;
+    return JSON.parse(text);
+  } catch { return null; }
+}
+
+const TIMEOUT = 2000;
+const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+
+function exec(cmd) {
+  try {
+    return execSync(cmd, { cwd: projectDir, timeout: TIMEOUT, encoding: 'utf8' }).trim();
+  } catch { return ''; }
+}
+
+function getProfile() {
+  return process.env.CLAUDE_HOOK_PROFILE || 'standard';
+}
+
+const STACK_SKIP_DIRS = new Set([
+  'node_modules', 'dist', 'build', '.git', '.next', '.turbo',
+  'vendor', 'target', 'bin', '__pycache__', '.venv', 'venv',
+  'coverage', 'tmp', 'temp',
+]);
+
+function detectStacksIn(dir) {
+  const found = [];
+  const markers = {
+    'go.mod': 'Go',
+    'Cargo.toml': 'Rust',
+    'pyproject.toml': 'Py',
+    'requirements.txt': 'Py',
+  };
+  for (const [file, label] of Object.entries(markers)) {
+    if (existsSync(join(dir, file))) found.push(label);
+  }
+  // TypeScript: need both package.json and tsconfig
+  if (existsSync(join(dir, 'package.json')) && existsSync(join(dir, 'tsconfig.json'))) {
+    found.push('TS');
+  } else if (existsSync(join(dir, 'package.json'))) {
+    found.push('JS');
+  }
+  return found;
+}
+
+function getStacks() {
+  const stacks = detectStacksIn(projectDir);
+  // Monorepo fallback: if root didn't yield a clear stack set, scan 1-level subdirs
+  if (stacks.length < 2) {
+    try {
+      for (const entry of readdirSync(projectDir, { withFileTypes: true })) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name.startsWith('.')) continue;
+        if (STACK_SKIP_DIRS.has(entry.name)) continue;
+        stacks.push(...detectStacksIn(join(projectDir, entry.name)));
+      }
+    } catch { /* skip */ }
+  }
+  return [...new Set(stacks)].sort();
+}
+
+function getGitInfo() {
+  const combined = exec('git branch --show-current 2>/dev/null && echo "---SEP---" && git diff --shortstat 2>/dev/null && echo "---SEP---" && git diff --cached --shortstat 2>/dev/null');
+  if (!combined) return { branch: '', dirty: false, staged: false };
+
+  const parts = combined.split('---SEP---').map(s => s.trim());
+  return {
+    branch: parts[0] || '',
+    dirty: !!parts[1],
+    staged: !!parts[2],
+  };
+}
+
+function getMigrationCount() {
+  const migDirs = ['migrations', 'db/migrations', 'db/migrate', 'prisma/migrations'];
+  for (const dir of migDirs) {
+    const full = join(projectDir, dir);
+    if (!existsSync(full)) continue;
+    try {
+      const entries = readdirSync(full).filter(f => !f.startsWith('.'));
+      if (entries.length > 0) return entries.length;
+    } catch { /* skip */ }
+  }
+  return 0;
+}
+
+function getHookCount() {
+  const hooksDir = join(projectDir, '.claude', 'scripts', 'hooks');
+  if (!existsSync(hooksDir)) return 0;
+  try {
+    return readdirSync(hooksDir).filter(f => f.endsWith('.sh')).length;
+  } catch { return 0; }
+}
+
+function getAgentCount() {
+  const agentsDir = join(projectDir, '.claude', 'agents');
+  if (!existsSync(agentsDir)) return 0;
+  try {
+    return readdirSync(agentsDir).filter(f => f.endsWith('.md')).length;
+  } catch { return 0; }
+}
+
+function getSuperkit() {
+  const metaFile = join(projectDir, '.claude', '.superkit-meta');
+  if (!existsSync(metaFile)) return '';
+  try {
+    const content = readFileSync(metaFile, 'utf8');
+    const match = content.match(/SUPERKIT_VERSION="([^"]+)"/);
+    return match ? match[1] : '';
+  } catch { return ''; }
+}
+
+// ── Parse effort level from payload ───────────────────
+// Claude Code 2.1.x may send { effort: "xhigh" } or { effort: { level: "xhigh" } }
+// or the env var CLAUDE_EFFORT (for hook contexts). Absent → return ''.
+function getEffortLevel(payload) {
+  // Live payload effort takes precedence — the CLI sends the real per-turn
+  // effort here, so a stale CLAUDE_EFFORT env var must not mask it.
+  // Payload shape: { effort: "xhigh" } or { effort: { level: "xhigh" } }
+  if (payload != null) {
+    const e = payload.effort;
+    if (typeof e === 'string' && e) return e;
+    if (e != null && typeof e === 'object' && e.level != null) return String(e.level);
+  }
+  // Fall back to the env var (available in hook runs / older CLIs).
+  return process.env.CLAUDE_EFFORT || '';
+}
+
+// ── Transcript tail scan (context fallback + ultracode marker) ────────────
+// Reads only the trailing ~256KB of the JSONL transcript (respects the 2s
+// render budget on huge transcripts), then scans BACKWARDS for the latest
+// usage record, and — in the same pass — tracks the last `/effort` echo
+// (`Set effort level to <value>`) so an ultracode session can show a badge.
+// Caveat: a marker older than the trailing window is missed (badge silently
+// off — fail-safe). Fully fail-open: any error → { used: null, ultra: false }.
+function scanTranscriptTail(transcriptPath) {
+  const empty = { used: null, ultra: false };
+  try {
+    if (typeof transcriptPath !== 'string' || !transcriptPath) return empty;
+    const fd = openSync(transcriptPath, 'r');
+    try {
+      const size = fstatSync(fd).size;
+      const readLen = Math.min(size, 262144);           // last ~256KB only
+      const buf = Buffer.alloc(readLen);
+      readSync(fd, buf, 0, readLen, size - readLen);
+      const lines = buf.toString('utf8').split('\n');
+      let used = null;
+      let lastEffortCmd = null;
+      for (const line of lines) {
+        const m = line.match(/Set effort level to (\w+)/);
+        if (m) lastEffortCmd = m[1];
+      }
+      for (let i = lines.length - 1; i >= 0; i--) {     // newest → oldest
+        const line = lines[i].trim();
+        if (!line || line[0] !== '{') continue;
+        let obj;
+        try { obj = JSON.parse(line); } catch { continue; }  // skip bad/truncated line
+        const usage = (obj && obj.message && obj.message.usage) || (obj && obj.usage);
+        if (usage && typeof usage === 'object'
+            && ('input_tokens' in usage || 'cache_read_input_tokens' in usage
+                || 'cache_creation_input_tokens' in usage)) {
+          used = (usage.input_tokens || 0)
+            + (usage.cache_read_input_tokens || 0)
+            + (usage.cache_creation_input_tokens || 0);
+          break;
+        }
+      }
+      return { used, ultra: lastEffortCmd === 'ultracode' };
+    } finally { closeSync(fd); }
+  } catch { return empty; }
+}
+
+// Resolve the context window size for the transcript fallback path.
+// Precedence: env override → model '[1m]' marker → >200k heuristic → 200k default.
+function resolveContextWindowTokens(usedTokens, modelString) {
+  const env = process.env.CLAUDE_CONTEXT_TOKENS_MAX;
+  if (typeof env === 'string' && env.trim()) {
+    const n = parseInt(env, 10);
+    if (Number.isFinite(n) && n > 0) return n;
+  }
+  if (typeof modelString === 'string' && /\[1m\]/i.test(modelString)) return 1000000;
+  if (typeof usedTokens === 'number' && usedTokens > 200000) return 1000000;
+  return 200000;
+}
+
+// ── Shared bar rendering (ctx + rate limits speak one visual language) ─────
+function bar10(pct) {
+  const filled = Math.max(0, Math.min(10, Math.round((pct / 100) * 10)));
+  return '█'.repeat(filled) + '░'.repeat(10 - filled);
+}
+function heatColour(pct) {
+  return pct >= 80 ? '\x1b[31m' : pct >= 50 ? '\x1b[33m' : '\x1b[32m';
+}
+
+function renderCtxPct(pct) {
+  const p = Math.max(0, Math.min(100, Math.round(pct)));
+  return `ctx ${heatColour(p)}${bar10(p)}\x1b[0m ${p}%`;
+}
+function renderCtx(used, max) {
+  return renderCtxPct((used / max) * 100);
+}
+
+// ── Parse context budget from payload ─────────────────
+// Claude Code 2.1.x sends context_window as an OBJECT:
+//   { total_input_tokens, context_window_size, used_percentage, … }
+// Older CLIs sent a bare token count there; the oldest sent nothing at all,
+// in which case usage is measured from the transcript instead.
+function getContextBudget(payload, scanned) {
+  if (payload == null) return '';
+
+  const cw = payload.context_window;
+
+  if (cw && typeof cw === 'object') {
+    // used_percentage is the number the CLI itself reports in /context — prefer
+    // it, so the bar and /context can never disagree.
+    if (typeof cw.used_percentage === 'number') return renderCtxPct(cw.used_percentage);
+    if (typeof cw.total_input_tokens === 'number' && cw.context_window_size > 0) {
+      return renderCtx(cw.total_input_tokens, cw.context_window_size);
+    }
+    // Object present but carries no usable numbers → fall through to the transcript.
+  } else {
+    const used = cw ?? payload.context_tokens_used ?? null;
+    if (typeof used === 'number') {
+      const max = payload.context_window_max ?? payload.context_tokens_max
+        ?? (typeof process.env.CLAUDE_CONTEXT_TOKENS_MAX === 'string'
+            ? parseInt(process.env.CLAUDE_CONTEXT_TOKENS_MAX, 10) || null
+            : null)
+        ?? 1000000;  // default: Opus 4.8 1M
+      return renderCtx(used, max);
+    }
+  }
+
+  // Fallback path: no usable native field → measured from the transcript.
+  if (scanned && scanned.used != null) {
+    // Model string: the '[1m]' marker rides on model.id (e.g. claude-opus-4-8[1m]);
+    // combine id + display_name so either field can carry it.
+    const m = payload.model;
+    const modelString = typeof m === 'string'
+      ? m
+      : (m && typeof m === 'object' ? `${m.id || ''} ${m.display_name || ''}` : '');
+    const max = resolveContextWindowTokens(scanned.used, modelString);
+    return renderCtx(scanned.used, max);
+  }
+  return '';
+}
+
+// ── REAL 5h / weekly rate-limit bars ───────────────────────────────────────
+// Claude Code pipes rate_limits.{five_hour,seven_day}.{used_percentage,
+// resets_at} for Claude subscribers (same data as /usage). Absent (API-key
+// billing, session start) → segments silently skipped.
+function rateLimitSegments(payload) {
+  const out = [];
+  const rls = payload && payload.rate_limits;
+  if (!rls || typeof rls !== 'object') return out;
+  const seg = (label, rl) => {
+    if (!rl || typeof rl !== 'object') return null;
+    const pct = rl.used_percentage;
+    if (typeof pct !== 'number' || !Number.isFinite(pct)) return null;
+    const p = Math.max(0, Math.min(100, pct));
+    // resets_at arrives as epoch seconds OR an ISO string depending on CLI build
+    let resetSec = null;
+    const r = rl.resets_at;
+    if (typeof r === 'number' && r > 0) resetSec = r > 1e12 ? r / 1000 : r;
+    else if (typeof r === 'string' && r) {
+      const t = Date.parse(r);
+      if (Number.isFinite(t)) resetSec = t / 1000;
+    }
+    let eta = '';
+    if (resetSec) {
+      let sLeft = Math.max(0, Math.round(resetSec - Date.now() / 1000));
+      const d = Math.floor(sLeft / 86400);
+      const h = Math.floor((sLeft % 86400) / 3600);
+      const mm = Math.floor((sLeft % 3600) / 60);
+      eta = d > 0 ? ` ${d}d${h}h` : h > 0 ? ` ${h}h${mm}m` : ` ${mm}m`;
+    }
+    return `${label} ${heatColour(p)}${bar10(p)}\x1b[0m ${Math.round(p)}%${eta}`;
+  };
+  const s5 = seg('5h', rls.five_hour);
+  const sw = seg('W', rls.seven_day);
+  if (s5) out.push(s5);
+  if (sw) out.push(sw);
+  return out;
+}
+
+// ── Build status line ──────────────────────────────────
+const stdinPayload = readStdinPayload();
+
+const git = getGitInfo();
+const skVersion = getSuperkit();
+const effortLevel = getEffortLevel(stdinPayload);
+const tp = stdinPayload && typeof stdinPayload.transcript_path === 'string'
+  ? stdinPayload.transcript_path : '';
+const scanned = (tp && existsSync(tp)) ? scanTranscriptTail(tp) : { used: null, ultra: false };
+const contextBudget = getContextBudget(stdinPayload, scanned);
+
+const parts = [];
+
+// Claude Code paints uncoloured statusline text muted gray → the git branch
+// carries an explicit bright colour; CLAUDE_STATUSLINE_THEME=light flips it
+// to black for light terminals.
+const BRIGHT_FG = (process.env.CLAUDE_STATUSLINE_THEME || '').toLowerCase() === 'light' ? '\x1b[30m' : '\x1b[97m';
+
+// Superkit version — bold magenta, leads the line.
+if (skVersion) parts.push(`\x1b[1;35mv${skVersion}\x1b[0m`);
+
+// Git branch + status (bright fg)
+if (git.branch) {
+  let branchStr = git.branch;
+  if (git.staged) branchStr += '+';
+  if (git.dirty) branchStr += '*';
+  parts.push(`${BRIGHT_FG}${branchStr}\x1b[0m`);
+}
+
+// Model + effort (heat-graded) + ultracode badge.
+// Model in cyan; effort BOLD, coloured by intensity (high=green, xhigh=yellow,
+// max=red); ⟁ULTRA in bright magenta while the session's /effort is ultracode.
+{
+  const m = stdinPayload && stdinPayload.model;
+  const modelName = m && typeof m === 'object' ? (m.display_name || m.id) : (typeof m === 'string' ? m : '');
+  const effortColour = {
+    low: '\x1b[1;94m', medium: '\x1b[1;96m', high: '\x1b[1;92m',
+    xhigh: '\x1b[1;93m', max: '\x1b[1;91m',
+  }[effortLevel] || '\x1b[1;96m';
+  const effortStr = effortLevel ? `${effortColour}⚙${effortLevel}\x1b[0m` : '';
+  const ultraStr = scanned.ultra ? '\x1b[1;95m⟁ULTRA\x1b[0m' : '';
+  const segment = [modelName ? `\x1b[36m${modelName}\x1b[0m` : '', effortStr, ultraStr]
+    .filter(Boolean).join(' ');
+  if (segment) parts.push(segment);
+}
+
+// Context bar (native or transcript-derived) — absent on older CLIs w/o transcript
+if (contextBudget) parts.push(contextBudget);
+
+// Real 5h / weekly rate-limit bars (subscription sessions only)
+for (const seg of rateLimitSegments(stdinPayload)) parts.push(seg);
+
+process.stdout.write(parts.join(' | '));