tycono 0.1.57 → 0.1.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {

package/src/api/src/engine/context-assembler.ts

@@ -435,20 +435,37 @@ ${subInfo}
 **Use Bash to run the dispatch command:**
 
 \`\`\`bash
+# Start a job (returns immediately with job ID)
 python3 "$DISPATCH_CMD" ${exampleSubId} "Task description here"
+
+# Check job status/result later
+python3 "$DISPATCH_CMD" --check <jobId>
+
+# Start and wait for result (blocks up to 90s)
+python3 "$DISPATCH_CMD" --wait ${exampleSubId} "Task description here"
 \`\`\`
 
 **IMPORTANT**: Always use \`python3 "$DISPATCH_CMD"\` — this is the ONLY way to dispatch tasks to subordinates.
 
-The command will:
-1. Start a job for the subordinate
-2. Wait up to ~100 seconds for completion
-3. Return the subordinate's output if done, or a job ID to check later
+### Recommended Pattern: Parallel Dispatch
+
+For multiple tasks, dispatch all at once, then check results:
 
-If the subordinate takes longer than 100s, you'll get a job ID. Check the result with:
 \`\`\`bash
-python3 "$DISPATCH_CMD" --check <jobId>
-\`\`\``;
+# 1. Dispatch all tasks (each returns immediately)
+python3 "$DISPATCH_CMD" ${exampleSubId} "Task A"
+python3 "$DISPATCH_CMD" ${subordinates.length > 1 ? subordinates[1] : exampleSubId} "Task B"
+
+# 2. Check results later (use the Job IDs from step 1)
+python3 "$DISPATCH_CMD" --check <jobId-A>
+python3 "$DISPATCH_CMD" --check <jobId-B>
+\`\`\`
+
+### Status Values
+- **running** — Subordinate is working
+- **done** — Task completed, result available
+- **error** — Task failed
+- **awaiting_input** — Subordinate has a question for you`;
 
   // C-level roles get mandatory delegation rules
   if (isCLevel) {
@@ -480,19 +497,35 @@ When you receive a directive:
 
 ### The Supervision Loop (CRITICAL)
 
-After EVERY dispatch, follow this loop:
+After dispatching tasks, follow this loop:
 
 \`\`\`
-DISPATCH → WAIT → REVIEW → DECIDE
-                              ├── PASS → Knowledge Update → Task Update → Next Dispatch
-                              └── FAIL → Re-dispatch with feedback
+DISPATCH ALL → CHECK RESULTS → REVIEW → DECIDE
+                                          ├── PASS → Knowledge Update → Task Update → Next Dispatch
+                                          └── FAIL → Re-dispatch with feedback
 \`\`\`
 
+**Step 1: Dispatch all tasks** (fire-and-forget, collect job IDs)
+\`\`\`bash
+python3 "$DISPATCH_CMD" engineer "Task A"   # → job-xxx
+python3 "$DISPATCH_CMD" designer "Task B"   # → job-yyy
+\`\`\`
+
+**Step 2: Check results** (after waiting, use --check with saved job IDs)
+\`\`\`bash
+python3 "$DISPATCH_CMD" --check <job-xxx>
+python3 "$DISPATCH_CMD" --check <job-yyy>
+\`\`\`
+
+**Step 3-4: Review → Knowledge Update → Task Update → Next Dispatch**
 1. **Review**: Does the output meet acceptance criteria?
 2. **Knowledge Update**: Record decisions, findings, analysis in AKB (journals, knowledge/)
 3. **Task Update**: Update task status in tasks.md or project docs
 4. **Next Dispatch**: Identify and dispatch the next task
 
+⚠️ Do NOT use curl or other methods to create jobs — always use the dispatch command.
+⚠️ Do NOT use sleep loops to wait — use --check to poll for results.
+
 ### Dispatch Quality Requirements
 
 Every dispatch MUST include:

package/src/api/src/engine/runners/claude-cli.ts

@@ -13,9 +13,10 @@ import type { ExecutionRunner, RunnerConfig, RunnerCallbacks, RunnerHandle, Runn
 const DISPATCH_SCRIPT = `#!/usr/bin/env python3
 """dispatch-bridge: CLI runner가 하위 Role에게 작업을 할당하는 브릿지 스크립트.
 
-2가지 모드:
-  dispatch <roleId> "<task>"           — Job 시작 + 결과 대기 (최대 100초)
-  dispatch --check <jobId>             — 완료된 Job 결과 조회
+3가지 모드:
+  dispatch <roleId> "<task>"           — Job 시작 (즉시 반환, 대기하지 않음)
+  dispatch --check <jobId>             — Job 상태 및 결과 조회
+  dispatch --wait <roleId> "<task>"    — Job 시작 + 완료 대기 (최대 90초)
 
 환경변수:
   DISPATCH_API_URL    — API 서버 URL (default: http://localhost:3001)
@@ -44,14 +45,64 @@ def get_result(job_id):
     except Exception as e:
         return f'ERROR: Failed to get result: {e}'
 
+def get_status(job_id):
+    info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=5).read())
+    return info.get('status', 'unknown')
+
+def start_job(role_id, task):
+    parent_job = os.environ.get('DISPATCH_PARENT_JOB', '')
+    source_role = os.environ.get('DISPATCH_SOURCE_ROLE', 'ceo')
+    body = json.dumps({
+        'type': 'assign',
+        'roleId': role_id,
+        'task': task,
+        'sourceRole': source_role,
+        'parentJobId': parent_job if parent_job else None,
+    }).encode()
+    req = urllib.request.Request(f'{api}/api/jobs', body, {'Content-Type': 'application/json'})
+    resp = json.loads(urllib.request.urlopen(req, timeout=10).read())
+    return resp['jobId']
+
+def poll_until_done(job_id, role_id, max_wait=90):
+    waited = 0
+    while waited < max_wait:
+        try:
+            status = get_status(job_id)
+            if status == 'done':
+                log('')
+                log(f'=== {role_id.upper()} Result (done) ===')
+                log(get_result(job_id))
+                return
+            elif status == 'error':
+                log('')
+                log(f'=== {role_id.upper()} Result (error) ===')
+                log(get_result(job_id))
+                return
+            elif status == 'awaiting_input':
+                log('')
+                log(f'{role_id.upper()} is asking a question (awaiting_input).')
+                log(f'Check details: python3 "$DISPATCH_CMD" --check {job_id}')
+                return
+        except Exception:
+            pass
+        time.sleep(5)
+        waited += 5
+        if waited % 15 == 0:
+            log(f'  ... {role_id} still working ({waited}s)')
+    log('')
+    log(f'{role_id.upper()} is still working after {waited}s.')
+    log(f'Check result later: python3 "$DISPATCH_CMD" --check {job_id}')
+
 # Mode: --check <jobId>
 if len(sys.argv) >= 3 and sys.argv[1] == '--check':
     job_id = sys.argv[2]
     try:
-        info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=10).read())
-        status = info.get('status', 'unknown')
+        status = get_status(job_id)
         if status == 'running':
             log(f'Job {job_id} is still running. Try again later.')
+        elif status == 'awaiting_input':
+            log(f'Job {job_id} is awaiting input (subordinate asked a question).')
+            log(get_result(job_id))
         else:
             log(f'=== Job {job_id}: {status} ===')
             log(get_result(job_id))
@@ -59,33 +110,29 @@ if len(sys.argv) >= 3 and sys.argv[1] == '--check':
         log(f'ERROR: {e}')
     sys.exit(0)
 
-# Mode: dispatch <roleId> "<task>"
-if len(sys.argv) < 3:
-    log('Usage: dispatch <roleId> "<task>"')
-    log('       dispatch --check <jobId>')
+# Mode: --wait <roleId> "<task>" (start + wait)
+wait_mode = False
+args = sys.argv[1:]
+if args and args[0] == '--wait':
+    wait_mode = True
+    args = args[1:]
+
+# Usage check
+if len(args) < 2:
+    log('Usage: dispatch <roleId> "<task>"          — Start job (immediate return)')
+    log('       dispatch --wait <roleId> "<task>"   — Start job + wait for result')
+    log('       dispatch --check <jobId>            — Check job status/result')
     subs = os.environ.get('DISPATCH_SUBORDINATES', '')
     if subs:
         log(f'Available subordinates: {subs}')
     sys.exit(1)
 
-role_id = sys.argv[1]
-task = ' '.join(sys.argv[2:])
-parent_job = os.environ.get('DISPATCH_PARENT_JOB', '')
-source_role = os.environ.get('DISPATCH_SOURCE_ROLE', 'ceo')
+role_id = args[0]
+task = ' '.join(args[1:])
 
 # Start job
-body = json.dumps({
-    'type': 'assign',
-    'roleId': role_id,
-    'task': task,
-    'sourceRole': source_role,
-    'parentJobId': parent_job if parent_job else None,
-}).encode()
-
 try:
-    req = urllib.request.Request(f'{api}/api/jobs', body, {'Content-Type': 'application/json'})
-    resp = json.loads(urllib.request.urlopen(req, timeout=10).read())
-    job_id = resp['jobId']
+    job_id = start_job(role_id, task)
 except Exception as e:
     log(f'ERROR: Failed to start dispatch job: {e}')
     sys.exit(1)
@@ -94,26 +141,13 @@ log(f'=== Dispatched to {role_id.upper()} ===')
 log(f'Task: {task[:120]}')
 log(f'Job ID: {job_id}')
 
-# Wait for completion (max ~100s to stay within Bash timeout)
-status = 'running'
-waited = 0
-while waited < 100:
-    try:
-        info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=5).read())
-        status = info.get('status', 'unknown')
-        if status in ('done', 'error'):
-            break
-    except Exception:
-        pass
-    time.sleep(3)
-    waited += 3
-
-if status in ('done', 'error'):
-    log(f'\\n=== {role_id.upper()} Result ({status}) ===')
-    log(get_result(job_id))
+if wait_mode:
+    log(f'Waiting for completion...')
+    poll_until_done(job_id, role_id)
 else:
-    log(f'\\n{role_id.upper()} is still working (waited {waited}s).')
-    log(f'Check result later: python3 "$DISPATCH_CMD" --check {job_id}')
+    log('')
+    log(f'Job started. Check result with:')
+    log(f'  python3 "$DISPATCH_CMD" --check {job_id}')
 `;
 
 /* ─── Consult Bridge Script (Python3) ────── */
@@ -122,7 +156,7 @@ const CONSULT_SCRIPT = `#!/usr/bin/env python3
 """consult-bridge: CLI runner가 다른 Role에게 질문하는 브릿지 스크립트.
 
 사용법:
-  consult <roleId> "<question>"          — Job 시작 (readOnly) + 결과 대기
+  consult <roleId> "<question>"          — Job 시작 (readOnly) + 결과 대기 (최대 90초)
   consult --check <jobId>                — 완료된 Job 결과 조회
 
 환경변수:
@@ -152,14 +186,20 @@ def get_result(job_id):
     except Exception as e:
         return f'ERROR: Failed to get result: {e}'
 
+def get_status(job_id):
+    info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=5).read())
+    return info.get('status', 'unknown')
+
 # Mode: --check <jobId>
 if len(sys.argv) >= 3 and sys.argv[1] == '--check':
     job_id = sys.argv[2]
     try:
-        info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=10).read())
-        status = info.get('status', 'unknown')
+        status = get_status(job_id)
         if status == 'running':
             log(f'Job {job_id} is still running. Try again later.')
+        elif status == 'awaiting_input':
+            log(f'Job {job_id} is awaiting input.')
+            log(get_result(job_id))
         else:
             log(f'=== Job {job_id}: {status} ===')
             log(get_result(job_id))
@@ -200,27 +240,37 @@ except Exception as e:
 log(f'=== Consulting {role_id.upper()} ===')
 log(f'Question: {question[:120]}')
 log(f'Job ID: {job_id}')
+log(f'Waiting for answer...')
 
-# Wait for completion (max ~100s)
-status = 'running'
+# Wait for completion (max ~90s — consult is read-only, usually fast)
 waited = 0
-while waited < 100:
+while waited < 90:
     try:
-        info = json.loads(urllib.request.urlopen(f'{api}/api/jobs/{job_id}', timeout=5).read())
-        status = info.get('status', 'unknown')
-        if status in ('done', 'error'):
-            break
+        status = get_status(job_id)
+        if status == 'done':
+            log('')
+            log(f'=== {role_id.upper()} Answer ===')
+            log(get_result(job_id))
+            sys.exit(0)
+        elif status == 'error':
+            log('')
+            log(f'=== {role_id.upper()} Error ===')
+            log(get_result(job_id))
+            sys.exit(1)
+        elif status == 'awaiting_input':
+            log('')
+            log(f'{role_id.upper()} needs clarification. Check: python3 "$CONSULT_CMD" --check {job_id}')
+            sys.exit(0)
     except Exception:
         pass
-    time.sleep(3)
-    waited += 3
-
-if status in ('done', 'error'):
-    log(f'\\n=== {role_id.upper()} Answer ({status}) ===')
-    log(get_result(job_id))
-else:
-    log(f'\\n{role_id.upper()} is still thinking (waited {waited}s).')
-    log(f'Check result later: python3 "$CONSULT_CMD" --check {job_id}')
+    time.sleep(5)
+    waited += 5
+    if waited % 15 == 0:
+        log(f'  ... {role_id} still thinking ({waited}s)')
+
+log('')
+log(f'{role_id.upper()} is still thinking after {waited}s.')
+log(f'Check result later: python3 "$CONSULT_CMD" --check {job_id}')
 `;
 
 /* ─── Claude CLI Runner ──────────────────────── */

package/src/api/src/routes/save.ts

@@ -1,23 +1,30 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { COMPANY_ROOT } from '../services/file-reader.js';
-import { getGitStatus, gitSave, gitHistory, gitRestore, gitInit } from '../services/git-save.js';
+import { getGitStatus, gitSave, gitHistory, gitRestore, gitInit, gitFetchStatus, gitPull } from '../services/git-save.js';
+import type { RepoType } from '../services/git-save.js';
 
 export const saveRouter = Router();
 
-// GET /api/save/status
-saveRouter.get('/status', (_req: Request, res: Response, next: NextFunction) => {
+/** Extract repo type from query param, default 'akb' */
+function getRepo(req: Request): RepoType {
+  const repo = req.query.repo;
+  return repo === 'code' ? 'code' : 'akb';
+}
+
+// GET /api/save/status?repo=akb|code
+saveRouter.get('/status', (req: Request, res: Response, next: NextFunction) => {
   try {
-    res.json(getGitStatus(COMPANY_ROOT));
+    res.json(getGitStatus(COMPANY_ROOT, getRepo(req)));
   } catch (err) {
     next(err);
   }
 });
 
-// POST /api/save — commit + push
+// POST /api/save?repo=akb|code — commit + push
 saveRouter.post('/', (req: Request, res: Response, next: NextFunction) => {
   try {
     const { message } = req.body ?? {};
-    const result = gitSave(COMPANY_ROOT, message);
+    const result = gitSave(COMPANY_ROOT, message, getRepo(req));
     res.json({ ok: true, ...result });
   } catch (err) {
     if (err instanceof Error && err.message === 'No changes to save') {
@@ -28,11 +35,11 @@ saveRouter.post('/', (req: Request, res: Response, next: NextFunction) => {
   }
 });
 
-// GET /api/save/history
+// GET /api/save/history?repo=akb|code
 saveRouter.get('/history', (req: Request, res: Response, next: NextFunction) => {
   try {
     const limit = Math.min(Number(req.query.limit) || 20, 100);
-    res.json(gitHistory(COMPANY_ROOT, limit));
+    res.json(gitHistory(COMPANY_ROOT, limit, getRepo(req)));
   } catch (err) {
     next(err);
   }
@@ -66,3 +73,26 @@ saveRouter.post('/restore', (req: Request, res: Response, next: NextFunction) =>
     next(err);
   }
 });
+
+// GET /api/save/sync-status?repo=akb|code — fetch + ahead/behind
+saveRouter.get('/sync-status', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    res.json(gitFetchStatus(COMPANY_ROOT, getRepo(req)));
+  } catch (err) {
+    next(err);
+  }
+});
+
+// POST /api/save/pull?repo=akb|code — safe pull (ff-only)
+saveRouter.post('/pull', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const result = gitPull(COMPANY_ROOT, getRepo(req));
+    const statusCode = result.status === 'ok' || result.status === 'up-to-date' ? 200
+      : result.status === 'dirty' || result.status === 'diverged' ? 409
+      : result.status === 'no-remote' ? 404
+      : 500;
+    res.status(statusCode).json(result);
+  } catch (err) {
+    next(err);
+  }
+});

package/src/api/src/routes/setup.ts

@@ -278,6 +278,16 @@ setupRouter.post('/import-knowledge', (req, res) => {
   });
 });
 
+/**
+ * GET /api/setup/code-root
+ * Get the current codeRoot config value.
+ */
+setupRouter.get('/code-root', (_req, res) => {
+  const companyRoot = process.env.COMPANY_ROOT || process.cwd();
+  const config = readConfig(companyRoot);
+  res.json({ codeRoot: config.codeRoot || null });
+});
+
 /**
  * POST /api/setup/code-root
  * Set or update the codeRoot config field.
@@ -297,10 +307,24 @@ setupRouter.post('/code-root', (req, res) => {
     return;
   }
 
+  if (!fs.statSync(resolved).isDirectory()) {
+    res.status(400).json({ ok: false, error: 'Path is not a directory' });
+    return;
+  }
+
+  // Check if it's a git repository
+  let isGitRepo = false;
+  try {
+    execSync('git rev-parse --git-dir', { cwd: resolved, timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] });
+    isGitRepo = true;
+  } catch {
+    // Not a git repo — still allow, but inform
+  }
+
   const config = readConfig(companyRoot);
   writeConfig(companyRoot, { ...config, codeRoot: resolved });
 
-  res.json({ ok: true, codeRoot: resolved });
+  res.json({ ok: true, codeRoot: resolved, isGitRepo });
 });
 
 /**

package/src/api/src/services/git-save.ts

@@ -50,6 +50,22 @@ export interface RestoreResult {
   restoredFiles: string[];
 }
 
+export interface PullResult {
+  status: 'ok' | 'dirty' | 'diverged' | 'up-to-date' | 'no-remote' | 'error';
+  message: string;
+  commits?: number;
+  behind?: number;
+  ahead?: number;
+}
+
+export interface SyncStatus {
+  ahead: number;
+  behind: number;
+  branch: string;
+  remote: string;
+  hasRemote: boolean;
+}
+
 /**
  * Paths to include in save (relative to root).
  * Only AKB files — never user source code.
@@ -356,3 +372,102 @@ export function gitRestore(root: string, sha: string, paths?: string[], repo: Re
 
   return { commitSha: newSha, restoredFiles };
 }
+
+/**
+ * Fetch remote and return ahead/behind status
+ * @param root - AKB repository root (COMPANY_ROOT)
+ * @param repo - Repository type ('akb' or 'code'), default 'akb'
+ */
+export function gitFetchStatus(root: string, repo: RepoType = 'akb'): SyncStatus {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (!isGitRepo(repoRoot)) {
+    return { ahead: 0, behind: 0, branch: '', remote: '', hasRemote: false };
+  }
+
+  const branch = run('git rev-parse --abbrev-ref HEAD', repoRoot) || 'unknown';
+  const hasRemote = !!run('git remote', repoRoot);
+
+  if (!hasRemote) {
+    return { ahead: 0, behind: 0, branch, remote: '', hasRemote: false };
+  }
+
+  // Fetch from remote (timeout 15s for network)
+  try {
+    execSync('git fetch origin', { cwd: repoRoot, encoding: 'utf-8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] });
+  } catch {
+    // Fetch failed (no network, etc.) — return what we know
+    return { ahead: 0, behind: 0, branch, remote: 'origin', hasRemote: true };
+  }
+
+  // Count ahead/behind
+  const revList = run(`git rev-list --left-right --count HEAD...origin/${branch}`, repoRoot);
+  let ahead = 0;
+  let behind = 0;
+  if (revList) {
+    const parts = revList.split(/\s+/);
+    ahead = parseInt(parts[0], 10) || 0;
+    behind = parseInt(parts[1], 10) || 0;
+  }
+
+  return { ahead, behind, branch, remote: 'origin', hasRemote: true };
+}
+
+/**
+ * Safe pull (fast-forward only)
+ * @param root - AKB repository root (COMPANY_ROOT)
+ * @param repo - Repository type ('akb' or 'code'), default 'akb'
+ */
+export function gitPull(root: string, repo: RepoType = 'akb'): PullResult {
+  const repoRoot = resolveRepoRoot(root, repo);
+
+  if (!isGitRepo(repoRoot)) {
+    return { status: 'error', message: 'Not a git repository' };
+  }
+
+  const branch = run('git rev-parse --abbrev-ref HEAD', repoRoot) || 'unknown';
+  const hasRemote = !!run('git remote', repoRoot);
+
+  if (!hasRemote) {
+    return { status: 'no-remote', message: 'No remote configured' };
+  }
+
+  // Fetch first
+  try {
+    execSync('git fetch origin', { cwd: repoRoot, encoding: 'utf-8', timeout: 15000, stdio: ['pipe', 'pipe', 'pipe'] });
+  } catch {
+    return { status: 'error', message: 'Failed to fetch from remote' };
+  }
+
+  // Check for uncommitted changes
+  const porcelain = run('git status --porcelain', repoRoot);
+  if (porcelain) {
+    return { status: 'dirty', message: 'Uncommitted changes — save or stash before pulling' };
+  }
+
+  // Check ahead/behind
+  const revList = run(`git rev-list --left-right --count HEAD...origin/${branch}`, repoRoot);
+  let ahead = 0;
+  let behind = 0;
+  if (revList) {
+    const parts = revList.split(/\s+/);
+    ahead = parseInt(parts[0], 10) || 0;
+    behind = parseInt(parts[1], 10) || 0;
+  }
+
+  if (behind === 0) {
+    return { status: 'up-to-date', message: 'Already up to date', ahead, behind: 0 };
+  }
+
+  if (ahead > 0 && behind > 0) {
+    return { status: 'diverged', message: `Branches diverged (${ahead} ahead, ${behind} behind) — manual merge needed`, ahead, behind };
+  }
+
+  // Safe fast-forward pull
+  try {
+    runOrThrow(`git pull --ff-only origin ${branch}`, repoRoot);
+    return { status: 'ok', message: `Pulled ${behind} commit(s)`, commits: behind, ahead: 0, behind: 0 };
+  } catch (err) {
+    return { status: 'error', message: err instanceof Error ? err.message : 'Pull failed' };
+  }
+}

package/src/api/src/utils/role-level.ts

@@ -1,39 +1,26 @@
 /**
  * role-level.ts — Server-side role level calculation
  *
- * Mirrors the frontend level thresholds so the chat system prompt
- * can reference a role's current level and team stats.
+ * Mirrors the frontend level system.
+ * Formula: level = floor(√(tokens ÷ 50,000))
+ * Infinite levels, quadratic scaling.
  */
 
-const THRESHOLDS = [
-  0,           // Lv.1
-  10_000,      // Lv.2
-  50_000,      // Lv.3
-  150_000,     // Lv.4
-  400_000,     // Lv.5
-  1_000_000,   // Lv.6
-  2_500_000,   // Lv.7
-  5_000_000,   // Lv.8
-  10_000_000,  // Lv.9
-  25_000_000,  // Lv.10
-];
+const BASE_XP = 50_000;
 
 export function calcLevel(totalTokens: number): number {
-  let level = 1;
-  for (let i = THRESHOLDS.length - 1; i >= 0; i--) {
-    if (totalTokens >= THRESHOLDS[i]) {
-      level = i + 1;
-      break;
-    }
-  }
-  return Math.min(level, 10);
+  if (totalTokens < BASE_XP) return 1;
+  return Math.max(1, Math.floor(Math.sqrt(totalTokens / BASE_XP)));
+}
+
+export function tokensForLevel(level: number): number {
+  return BASE_XP * level * level;
 }
 
 export function calcProgress(totalTokens: number): number {
   const level = calcLevel(totalTokens);
-  if (level >= 10) return 1;
-  const current = THRESHOLDS[level - 1];
-  const next = THRESHOLDS[level];
+  const current = tokensForLevel(level);
+  const next = tokensForLevel(level + 1);
   return Math.min(1, (totalTokens - current) / (next - current));
 }