@axplusb/kepler 2.0.7 → 2.3.0

package/src/core/tool-executor.mjs

@@ -9,12 +9,13 @@
  */
 
 import { createToolRegistry } from '../tools/registry.mjs';
-import { filterOutput } from './output-filter.mjs';
+import { detectCommandType, filterOutput } from './output-filter.mjs';
 import { validatePath, validateDelete, validateShellCommand, validateWrite } from './safety.mjs';
 import { classifyCommand, isExitCodeError } from '../permissions/command-classifier.mjs';
 import { analyzeCode } from '../context/ast-parser.mjs';
 import { ProjectRegistry } from '../tools/project-overview.mjs';
 import { SkillsLoader } from '../skills/loader.mjs';
+import { HookRunner } from '../config/hook-runner.mjs';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { execSync } from 'node:child_process';
@@ -29,6 +30,7 @@ export function createToolExecutor({
     projectRegistry = new ProjectRegistry(),
     skillsLoader = new SkillsLoader().load(process.cwd()),
     checkpoints = null,
+    hookRunner = null,
 } = {}) {
     const occRegistry = createToolRegistry();
     const skillTool = occRegistry.get('Skill');
@@ -49,6 +51,43 @@ export function createToolExecutor({
         return resolvePath(args.cwd || null, args);
     }
 
+    function longRunningObservationTimeoutMs() {
+        const configured = Number(process.env.KEPLER_LONG_RUNNING_TIMEOUT_MS);
+        return Number.isFinite(configured) && configured > 0 ? configured : 15_000;
+    }
+
+    function isLikelyLongRunningCommand(command) {
+        const cmd = String(command || '').trim();
+        if (!cmd) return false;
+        if (/^(?:timeout|gtimeout)\s+\S+\s+/i.test(cmd)) return false;
+        if (/(?:^|[;&|]\s*)(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|preview)\b/i.test(cmd)) return true;
+        if (/(?:^|[;&|]\s*)(?:vite|next|nuxt|astro|webpack-dev-server)\b/i.test(cmd)) return true;
+        if (/\b(?:uvicorn|gunicorn|flask\s+run|rails\s+server|bin\/rails\s+server|django-admin\s+runserver|manage\.py\s+runserver)\b/i.test(cmd)) return true;
+        if (/\b(?:python|python3)\s+-m\s+http\.server\b/i.test(cmd)) return true;
+        if (/\bnode\b[\s\S]*(?:setInterval|\.listen\s*\(|createServer\s*\()/i.test(cmd)) return true;
+        if (/\b(?:docker\s+compose|docker-compose)\s+up\b(?![\s\S]*\s-d\b)/i.test(cmd)) return true;
+        if (/\btail\s+-f\b/i.test(cmd)) return true;
+        if (/\b(?:--watch|watch)\b/i.test(cmd)) return true;
+        return false;
+    }
+
+    function limitTail(text, maxChars = 8000) {
+        const value = String(text || '');
+        if (value.length <= maxChars) return value;
+        return `... (tail truncated)\n${value.slice(value.length - maxChars)}`;
+    }
+
+    function formatObservationTimeoutOutput(rawOutput, timeoutMs) {
+        const tail = String(rawOutput || '')
+            .replace(/^Error:\s*Command timed out after \d+ms\s*/i, '')
+            .trim();
+        const body = tail || '(no output captured before timeout)';
+        return limitTail(
+            `Observation timeout after ${timeoutMs}ms for a likely long-running command. ` +
+            `The process was stopped after collecting the output tail.\n${body}`
+        );
+    }
+
     function updateProjectIndex(filePath) {
         try {
             projectRegistry.projectForPath(filePath)?.retriever.updateFile(filePath);
@@ -215,20 +254,31 @@ export function createToolExecutor({
                 }
             }
 
+            const observationTimeout = args.timeout == null && isLikelyLongRunningCommand(args.command);
+            const effectiveTimeout = observationTimeout ? longRunningObservationTimeoutMs() : args.timeout;
             const result = await occRegistry.call('Bash', {
                 command: args.command,
-                timeout: args.timeout,
+                timeout: effectiveTimeout,
                 description: args.description || `Run: ${(args.command || '').slice(0, 50)}`,
                 cwd,
             });
             const rawOutput = typeof result === 'string' ? result : String(result);
+            const timedOut = /^Error:\s*Command timed out after \d+ms/i.test(rawOutput);
             const exitMatch = rawOutput.match(/Exit code: (\d+)/);
-            const exitCode = exitMatch ? parseInt(exitMatch[1]) : 0;
+            const exitCode = timedOut ? 124 : (exitMatch ? parseInt(exitMatch[1]) : 0);
             // Semantic exit code: grep returns 1 for "no matches" (not an error)
-            const success = !isExitCodeError(args.command, exitCode);
+            const success = observationTimeout && timedOut ? true : (!timedOut && !isExitCodeError(args.command, exitCode));
 
             // Apply smart filtering based on command type
-            const filtered = filterOutput(rawOutput, args.command, success);
+            const filtered = observationTimeout && timedOut
+                ? {
+                    output: formatObservationTimeoutOutput(rawOutput, effectiveTimeout),
+                    commandType: detectCommandType(args.command),
+                    truncated: false,
+                    originalLines: rawOutput.split('\n').length,
+                    filteredLines: rawOutput.split('\n').length,
+                }
+                : filterOutput(rawOutput, args.command, success);
 
             return {
                 success,
@@ -238,6 +288,9 @@ export function createToolExecutor({
                 _classification: args._classification,
                 _commandType: filtered.commandType,
                 _filtered: filtered.truncated || filtered.originalLines !== filtered.filteredLines,
+                _timed_out: timedOut,
+                _observation_timeout: observationTimeout && timedOut,
+                _observation_timeout_ms: observationTimeout && timedOut ? effectiveTimeout : undefined,
             };
         },
 
@@ -875,8 +928,21 @@ print('OK: replaced')
             if (!handler) {
                 return { success: false, output: `Unknown tool: ${name}`, _tool: name };
             }
+            const hooks = hookRunner || new HookRunner({ cwd: process.cwd() });
             try {
-                return await handler(args);
+                const pre = await hooks.run('PreToolUse', { toolName: name, input: args || {} });
+                if (pre.blocked) {
+                    return { success: false, output: `BLOCKED by hook: ${pre.message}`, _tool: name, _blocked: true };
+                }
+                let result = await handler(args);
+                const post = await hooks.run('PostToolUse', { toolName: name, input: args || {}, result });
+                for (const item of post.results || []) {
+                    if (item.parsed?.modifiedResult !== undefined) result = item.parsed.modifiedResult;
+                    if (item.parsed?.feedback && result && typeof result === 'object') {
+                        result.output = `${result.output || ''}\n\n--- Hook Feedback ---\n${item.parsed.feedback}`.trim();
+                    }
+                }
+                return result;
             } catch (err) {
                 return { success: false, output: `Tool error (${name}): ${err.message}`, _tool: name };
             }

package/src/core/trust.mjs

@@ -0,0 +1,158 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { TIERS } from './risk-tier.mjs';
+
+function trustPath(cwd) {
+  return path.join(cwd, '.kepler', 'trust.json');
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function commandShape(command) {
+  const parts = String(command || '').trim().split(/\s+/).filter(Boolean);
+  return parts.slice(0, 2).join(' ');
+}
+
+function shellPattern(args) {
+  const shape = commandShape(args?.command);
+  return shape ? `${shape}*` : '*';
+}
+
+function pathPattern(args) {
+  const p = String(args?.file_path || args?.path || '').trim();
+  if (!p) return '*';
+  const dir = path.dirname(p);
+  return dir === '.' ? p : path.join(dir, '**');
+}
+
+export function patternFor(tool, args = {}) {
+  if (tool === 'shell') return shellPattern(args);
+  return pathPattern(args);
+}
+
+function matches(pattern, value) {
+  if (!pattern || pattern === '*') return true;
+  if (pattern.endsWith('*')) return String(value || '').startsWith(pattern.slice(0, -1));
+  if (pattern.endsWith('/**')) return String(value || '').startsWith(pattern.slice(0, -3));
+  return pattern === value;
+}
+
+function valueFor(tool, args = {}) {
+  if (tool === 'shell') return String(args.command || '');
+  return String(args.file_path || args.path || '');
+}
+
+export class TrustStore {
+  constructor({ cwd = process.cwd(), policy = {} } = {}) {
+    this.cwd = cwd;
+    this.policy = policy;
+    this.sessionRules = [];
+  }
+
+  loadProjectRules() {
+    try {
+      const file = trustPath(this.cwd);
+      if (!fs.existsSync(file)) return [];
+      const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+      return Array.isArray(data.rules) ? data.rules : [];
+    } catch {
+      return [];
+    }
+  }
+
+  saveProjectRules(rules) {
+    const file = trustPath(this.cwd);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ version: 1, rules }, null, 2) + '\n');
+  }
+
+  allRules() {
+    return [...this.sessionRules, ...this.loadProjectRules()];
+  }
+
+  find(tool, args = {}, tier = '') {
+    const value = valueFor(tool, args);
+    const rules = this.allRules().filter(rule => rule.tool === tool && matches(rule.pattern, value));
+    const deny = rules.find(rule => rule.decision === 'deny');
+    if (deny) return { decision: 'deny', rule: deny };
+    const allow = rules.find(rule => rule.decision === 'allow');
+    if (!allow) return null;
+
+    const reask = this.shouldReask(allow, args, tier);
+    if (reask) return { decision: 'reask', rule: allow, reason: reask };
+    return { decision: 'allow', rule: allow };
+  }
+
+  shouldReask(rule, args = {}, tier = '') {
+    const reask = rule.reask || {};
+    const after = reask.after_minutes ?? this.policy.hitl?.reaskAfterMinutes;
+    if (after && rule.created_at) {
+      const ageMs = Date.now() - Date.parse(rule.created_at);
+      if (Number.isFinite(ageMs) && ageMs > after * 60 * 1000) {
+        return `approval expired after ${after}m`;
+      }
+    }
+    if ((reask.on_risk_increase ?? this.policy.hitl?.reaskOnRiskIncrease) && rule.tier && tier) {
+      const order = [TIERS.READ, TIERS.SHELL_SAFE, TIERS.LOCAL_EDIT, TIERS.SHELL_MEDIUM, TIERS.NETWORK, TIERS.SHELL_DANGEROUS, TIERS.DESTRUCTIVE];
+      if (order.indexOf(tier) > order.indexOf(rule.tier)) return 'risk tier increased';
+    }
+    if ((this.policy.hitl?.alwaysAskForDangerous ?? true) && (tier === TIERS.SHELL_DANGEROUS || tier === TIERS.DESTRUCTIVE)) {
+      return 'dangerous tier requires fresh approval';
+    }
+    if ((reask.on_command_shape_change ?? this.policy.hitl?.reaskOnCommandShapeChange) && rule.command_shape && args.command) {
+      if (rule.command_shape !== commandShape(args.command)) return 'command shape changed';
+    }
+    return '';
+  }
+
+  add({ tool, args = {}, tier, scope = 'SESSION', decision = 'allow' }) {
+    const normalizedScope = String(scope || 'SESSION').toUpperCase();
+    const pattern = patternFor(tool, args);
+    const id = `${tool}-${crypto.createHash('sha1').update(pattern + normalizedScope).digest('hex').slice(0, 10)}`;
+    const ttl = this.policy.hitl?.reaskAfterMinutes ?? 30;
+    const rule = {
+      id,
+      tool,
+      pattern,
+      scope: normalizedScope,
+      decision,
+      tier,
+      command_shape: tool === 'shell' ? commandShape(args.command) : undefined,
+      created_at: nowIso(),
+      expires_at: normalizedScope === 'SESSION'
+        ? new Date(Date.now() + ttl * 60 * 1000).toISOString()
+        : undefined,
+      reask: {
+        after_minutes: ttl,
+        on_command_shape_change: this.policy.hitl?.reaskOnCommandShapeChange ?? true,
+        on_risk_increase: this.policy.hitl?.reaskOnRiskIncrease ?? true,
+        on_path_boundary_change: this.policy.hitl?.reaskOnPathBoundaryChange ?? true,
+      },
+    };
+    if (normalizedScope === 'PROJECT') {
+      const rules = this.loadProjectRules().filter(r => r.id !== id);
+      rules.push(rule);
+      this.saveProjectRules(rules);
+    } else {
+      this.sessionRules = this.sessionRules.filter(r => r.id !== id);
+      this.sessionRules.push(rule);
+    }
+    return rule;
+  }
+
+  revoke() {
+    const active = this.sessionRules.length > 0;
+    this.sessionRules = [];
+    return active;
+  }
+
+  summary() {
+    return {
+      sessionRules: this.sessionRules.length,
+      projectRules: this.loadProjectRules().length,
+    };
+  }
+}

package/src/core/work-scope.mjs

@@ -0,0 +1,217 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+const SCHEMA = 'kepler.work_scope/1';
+const ROOT_MARKERS = [
+    '.kepler',
+    '.git',
+    'package.json',
+    'pyproject.toml',
+    'setup.py',
+    'go.mod',
+    'Cargo.toml',
+];
+
+function stable(value) {
+    if (Array.isArray(value)) return value.map(stable);
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(
+            Object.entries(value)
+                .filter(([, v]) => v !== undefined)
+                .sort(([a], [b]) => a.localeCompare(b))
+                .map(([k, v]) => [k, stable(v)]),
+        );
+    }
+    return value;
+}
+
+function sha(payload) {
+    return crypto
+        .createHash('sha256')
+        .update(JSON.stringify(stable(payload)))
+        .digest('hex')
+        .slice(0, 16);
+}
+
+function normalizePathInput(value) {
+    let s = String(value || '').trim();
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+        s = s.slice(1, -1);
+    }
+    if (s === '~' || s.startsWith('~/')) {
+        s = path.join(os.homedir(), s.slice(1));
+    }
+    return s.replace(/\\([ \t()&$;'"])/g, '$1');
+}
+
+function nearestProjectRoot(candidate) {
+    let resolved = normalizePathInput(candidate);
+    if (!resolved || !path.isAbsolute(resolved)) return null;
+
+    try {
+        resolved = fs.realpathSync(resolved);
+    } catch {
+        return null;
+    }
+
+    let dir = resolved;
+    try {
+        if (fs.statSync(resolved).isFile()) dir = path.dirname(resolved);
+    } catch {
+        return null;
+    }
+
+    const root = path.parse(dir).root;
+    let current = dir;
+    while (current && current !== root) {
+        if (ROOT_MARKERS.some(marker => fs.existsSync(path.join(current, marker)))) {
+            return fs.realpathSync(current);
+        }
+        current = path.dirname(current);
+    }
+    return fs.realpathSync(dir);
+}
+
+function extractQuotedPaths(text) {
+    const paths = [];
+    const re = /(['"])(\/[^'"\n]+)\1/g;
+    let match;
+    while ((match = re.exec(String(text || ''))) !== null) {
+        paths.push(match[2]);
+    }
+    return paths;
+}
+
+function extractPastedPaths(text) {
+    const source = String(text || '');
+    const paths = [];
+    for (let i = 0; i < source.length; i++) {
+        if (source[i] !== '/') continue;
+        const line = source.slice(i).split(/\r?\n/, 1)[0].replace(/[),.;:]+$/g, '');
+        const parts = line.split(/\s+/).filter(Boolean);
+        let candidate = '';
+        let lastRoot = null;
+        for (const part of parts.slice(0, 12)) {
+            candidate = candidate ? `${candidate} ${part}` : part;
+            const root = nearestProjectRoot(candidate.replace(/[),.;:]+$/g, ''));
+            if (root) lastRoot = root;
+        }
+        if (lastRoot) paths.push(lastRoot);
+    }
+    return paths;
+}
+
+function uniqueRoots(entries) {
+    const seen = new Set();
+    const result = [];
+    for (const entry of entries) {
+        if (!entry?.path || seen.has(entry.path)) continue;
+        seen.add(entry.path);
+        result.push(entry);
+    }
+    return result;
+}
+
+function roleForRoot(root, cwd) {
+    const base = path.basename(root).toLowerCase();
+    if (base.includes('backend')) return 'backend';
+    if (base.includes('frontend') || base.includes('web')) return 'frontend';
+    if (base.includes('deploy')) return 'deploy';
+    if (base.includes('docs') || base.includes('prd')) return 'docs';
+    if (base.includes('npm') || base.includes('cli')) return 'cli';
+    if (root === cwd) return 'primary';
+    return 'workspace';
+}
+
+function truncate(value, max = 280) {
+    const s = String(value || '').replace(/\s+/g, ' ').trim();
+    return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+
+function sortedResources(resources) {
+    return (Array.isArray(resources) ? resources : [])
+        .filter(resource => resource && resource.root)
+        .map(resource => ({
+            project_id: String(resource.project_id || ''),
+            root: String(resource.root || ''),
+            name: String(resource.name || path.basename(String(resource.root || ''))),
+            index_version: String(resource.index_version || ''),
+        }))
+        .sort((a, b) => a.root.localeCompare(b.root));
+}
+
+export function buildWorkScope({
+    instruction = '',
+    cwd = process.cwd(),
+    projectResources = [],
+} = {}) {
+    const cwdRoot = nearestProjectRoot(cwd) || path.resolve(cwd);
+    const roots = [{
+        path: cwdRoot,
+        role: roleForRoot(cwdRoot, cwdRoot),
+        source: 'cwd',
+        status: 'active',
+    }];
+
+    for (const raw of [...extractQuotedPaths(instruction), ...extractPastedPaths(instruction)]) {
+        const root = nearestProjectRoot(raw);
+        if (!root) continue;
+        roots.push({
+            path: root,
+            role: roleForRoot(root, cwdRoot),
+            source: 'prompt',
+            status: 'active',
+        });
+    }
+
+    for (const resource of sortedResources(projectResources)) {
+        roots.push({
+            path: resource.root,
+            role: roleForRoot(resource.root, cwdRoot),
+            source: 'registered',
+            status: 'active',
+            project_id: resource.project_id || undefined,
+        });
+    }
+
+    const activeRoots = uniqueRoots(roots);
+    const resources = sortedResources(projectResources);
+    const scope = {
+        schema: SCHEMA,
+        primary_root: cwdRoot,
+        intent: truncate(instruction),
+        active_roots: activeRoots,
+        candidate_roots: [],
+        workspace_resources: resources,
+        cache_policy: {
+            stable_system: false,
+            placement: 'pinned_context',
+            reason: 'scope changes with user intent and discovered roots',
+        },
+    };
+    scope.version = sha({
+        schema: scope.schema,
+        primary_root: scope.primary_root,
+        intent: scope.intent,
+        active_roots: scope.active_roots,
+        workspace_resources: scope.workspace_resources,
+    });
+    return scope;
+}
+
+export function summarizeWorkScope(scope) {
+    if (!scope || typeof scope !== 'object') return '';
+    const roots = Array.isArray(scope.active_roots) ? scope.active_roots : [];
+    const lines = [
+        `Work scope ${scope.version || 'unknown'}`,
+        `Primary: ${scope.primary_root || '(unknown)'}`,
+    ];
+    if (scope.intent) lines.push(`Intent: ${scope.intent}`);
+    for (const root of roots) {
+        if (!root?.path) continue;
+        lines.push(`- ${root.path} [${root.role || 'workspace'}; ${root.source || 'unknown'}]`);
+    }
+    return lines.join('\n');
+}

package/src/onboarding/preflight.mjs

@@ -30,6 +30,7 @@ import { URL } from 'node:url';
 import { paint } from '../ui/palette.mjs';
 import { icons } from '../ui/icons.mjs';
 import { term } from '../ui/term.mjs';
+import { formatMessageWindow, lowWindowStatus } from '../core/rate-limit-display.mjs';
 
 const OK   = (s) => `${paint.state.success('[✓]')} ${s}`;
 const WARN = (s) => `${paint.state.warn('[⚠]')} ${s}`;
@@ -37,18 +38,22 @@ const FAIL = (s) => `${paint.state.danger('[✗]')} ${s}`;
 
 // ── Individual checks (each returns { status, label, hint? }) ──────────
 
-async function checkAuthAndBackend(auth, { timeoutMs = 2500 } = {}) {
+export async function checkAuthAndBackend(auth, { timeoutMs } = {}) {
   const creds = auth.loadCredentials();
   const hasToken = !!creds.token;
   const url = creds.backendUrl;
+  // Local Docker backends round-trip Supabase and often take 2–4s. Give them
+  // more headroom so preflight doesn't falsely report Offline.
+  const isLocal = /^https?:\/\/(127\.0\.0\.1|localhost)(:|$|\/)/i.test(url || '');
+  timeoutMs = timeoutMs ?? (isLocal ? 8000 : 2500);
 
   // No token: just probe whether the backend is reachable so we can hint
   // /login when it makes sense.
   if (!hasToken) {
     const reachable = url ? await ping(url, timeoutMs).catch(() => false) : false;
     return reachable
-      ? { status: 'warn', label: 'Not signed in · backend ready', hint: '/login to sign in' }
-      : { status: 'warn', label: 'Not signed in · backend offline', hint: '/login once the network is back' };
+      ? { status: 'warn', label: 'Online', hint: '/login to sign in' }
+      : { status: 'warn', label: 'Offline' };
   }
 
   // Token present: real authenticated round-trip against /api/user/me.
@@ -66,15 +71,14 @@ async function checkAuthAndBackend(auth, { timeoutMs = 2500 } = {}) {
 
     if (resp.ok) {
       const user = await resp.json().catch(() => null);
-      const who = user?.github_username || user?.email || 'user';
-      return { status: 'ok', label: `Signed in as ${who} · connected`, user };
+      return { status: 'ok', label: 'Online', user };
     }
     if (resp.status === 401 || resp.status === 403) {
-      return { status: 'warn', label: 'Token expired · connected', hint: '/login again to refresh' };
+      return { status: 'warn', label: 'Online', hint: '/login again to refresh' };
     }
-    return { status: 'warn', label: `Backend returned ${resp.status}`, hint: 'try again shortly' };
+    return { status: 'warn', label: 'Offline' };
   } catch {
-    return { status: 'warn', label: 'Signed in · backend offline', hint: 'check network or try again shortly' };
+    return { status: 'warn', label: 'Offline' };
   }
 }
 
@@ -86,7 +90,7 @@ async function checkAuthAndBackend(auth, { timeoutMs = 2500 } = {}) {
  *   { status, label }                 — shown as a preflight row
  *   null                              — silent (e.g. BYOK or no signal)
  */
-async function checkCreditsAndPlan(auth, { timeoutMs = 2000 } = {}) {
+export async function checkCreditsAndPlan(auth, { timeoutMs = 2000 } = {}) {
   const creds = auth.loadCredentials();
   if (!creds.token || !creds.backendUrl) return null;
   try {
@@ -103,10 +107,22 @@ async function checkCreditsAndPlan(auth, { timeoutMs = 2000 } = {}) {
     const data = await resp.json().catch(() => null);
     if (!data) return null;
 
+    const tier = (data.tier || 'free').toUpperCase();
+    const windowLabel = formatMessageWindow(data.rate_limit);
+    if (windowLabel) {
+      const status = lowWindowStatus(data.rate_limit);
+      if (status === 'exhausted') {
+        return { status: 'fail', label: windowLabel, hint: 'message window exhausted — try again after reset' };
+      }
+      if (status === 'low') {
+        return { status: 'warn', label: windowLabel, hint: 'low message window — codekepler.ai/pricing' };
+      }
+      return { status: 'ok', label: windowLabel };
+    }
+
     if (data.byok_enabled) {
-      return { status: 'ok', label: `Plan: ${(data.tier || 'byok').toUpperCase()} · billed by your provider` };
+      return { status: 'ok', label: `Plan: ${tier || 'BYOK'} · billed by your provider` };
     }
-    const tier = (data.tier || 'free').toUpperCase();
     const remaining = data.balance?.total;
     if (typeof remaining !== 'number') {
       return { status: 'ok', label: `Plan: ${tier}` };