tillerhand 3.42.1 → 3.47.0

package/.claude/hooks/status-read.mjs

@@ -4,6 +4,7 @@
 // Must stay fast: the status line calls it on every refresh (git and heavy reads are in dashboard.mjs).
 import fs from 'node:fs';
 import path from 'node:path';
+import { t } from './lang.mjs';
 
 // Only a regular file: a folder or a link to a folder named like a test or report file must not throw (EISDIR)
 export const readText = (p) => { try { return fs.statSync(p).isFile() ? fs.readFileSync(p, 'utf8') : ''; } catch { return ''; } };
@@ -70,9 +71,9 @@ export function readStatus(root) {
     .map(([no, date, stage, topic, question, chosen, door, decidedBy]) => ({ no, date, stage, topic, question, chosen, door, decidedBy }));
 
   const checklists = [
-    ['Güvenlik', 'docs/security/checklist.md'], ['Canlıya alma', 'docs/operations/release-checklist.md'], ['Yasal / KVKK', 'docs/legal/privacy-kvkk.md'],
-    ['AI', 'docs/ai/guide.md'], ['Lansman', 'docs/product/launch.md'],
-  ].filter(([, f]) => fs.existsSync(d(f))).map(([name, f]) => ({ name, file: f, ...tally(readText(d(f))) }));
+    ['statusRead.checklist.security', 'docs/security/checklist.md'], ['statusRead.checklist.release', 'docs/operations/release-checklist.md'],
+    ['statusRead.checklist.legal', 'docs/legal/privacy-kvkk.md'], ['statusRead.checklist.ai', 'docs/ai/guide.md'], ['statusRead.checklist.launch', 'docs/product/launch.md'],
+  ].filter(([, f]) => fs.existsSync(d(f))).map(([name, f]) => ({ name: t(root, name), file: f, ...tally(readText(d(f))) }));
 
   let kit = null;
   try { kit = JSON.parse(readText(d('.kit.json'))); } catch { /* not set up */ }
@@ -91,7 +92,7 @@ export function readStatus(root) {
   const title = (f) => readText(d(f)).match(/^# (.+)$/m)?.[1].trim();
   return {
     // The project name is in AGENTS.md; in projects before 3.9.0 in CLAUDE.md (the update adds AGENTS.md with a placeholder)
-    project: [title('AGENTS.md'), title('CLAUDE.md')].find((a) => a && a !== '[PROJE ADI]') ?? title('AGENTS.md') ?? 'Proje',
+    project: [title('AGENTS.md'), title('CLAUDE.md')].find((a) => a && a !== '[PROJE ADI]') ?? title('AGENTS.md') ?? t(root, 'statusRead.defaultProject'),
     // type: null = set up by init, no type chosen yet (waiting for /start or /adopt)
     installed: !!kit && kit.type !== null,
     kitPending: kit ? kit.type === null : fs.existsSync(d('kit/kit.mjs')),

package/.claude/hooks/statusline.mjs

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 // Claude Code bottom status line: phase, task progress, question mode and usage limits.
-// Example: ▶ Faz 1 · G-012 · görev 7/23 · soru: açık (kapalı: tasarim) · 5s %34 · hf %5
+// Example: ▶ Faz 1 · G-012 · task 7/23 · questions: open (closed: tasarim) · 5h 34% · weekly 5%
 // Also writes the rate_limits Claude Code sends into .claude/state/usage.json (usage.mjs reads it).
 import fs from 'node:fs';
 import { readStatus } from './status-read.mjs';
 import { writeLimits, readLimits, level } from './usage.mjs';
+import { t } from './lang.mjs';
 
 let root = process.cwd();
 let input = {};
@@ -34,8 +35,8 @@ function limitPart() {
   const l = readLimits(root);
   if (!l) return null;
   const p = [];
-  if (l.five_hour) p.push(`5s %${Math.round(l.five_hour.percent)}`);
-  if (l.seven_day) p.push(`hf %${Math.round(l.seven_day.percent)}`);
+  if (l.five_hour) p.push(t(root, 'statusline.limit5h', { percent: Math.round(l.five_hour.percent) }));
+  if (l.seven_day) p.push(t(root, 'statusline.limitWeek', { percent: Math.round(l.seven_day.percent) }));
   const s = level(l);
   return p.join(' · ') + (s === 'yellow' ? ' ⚠' : s === 'red' ? ' ⛔' : '');
 }
@@ -44,22 +45,24 @@ try {
   const d = readStatus(root);
   const parts = [];
   if (d.kitPending) {
-    parts.push('◆ Kit kurulmadı · başlamak için: /start [fikrin] · var olan kod: /adopt');
+    parts.push(t(root, 'statusline.notSetUp'));
   } else {
     const a = d.fields;
+    // The values in progress.md stay Turkish (açık / kapalı); only what the line shows is localized
     const question = (a['Soru modu'] ?? 'açık')
+      .replace(/^(açık|kapalı)(?=$|\s)/i, (m) => t(root, m.toLowerCase() === 'açık' ? 'statusline.modeOpen' : 'statusline.modeOff'))
       .replace(/\s*·\s*kapalı konular:\s*yok/i, '')
-      .replace(/\s*·\s*kapalı konular:\s*(.*)$/i, ' (kapalı: $1)');
+      .replace(/\s*·\s*kapalı konular:\s*(.*)$/i, (_, topics) => ` ${t(root, 'statusline.closed', { topics })}`);
     parts.push(`▶ ${a['Aktif faz'] ?? '-'}`);
-    if (/başlangıç/i.test(a['Aktif faz'] ?? '')) parts.push(`adım ${a['Başlangıç adımı'] ?? '-'}`);
-    else parts.push(a['Aktif görev'] ?? '-', `görev ${d.taskCount.done}/${d.taskCount.total}`);
-    parts.push(`soru: ${question}`);
-    if (d.pending.length) parts.push(`bekleyen karar: ${d.pending.length}`);
+    if (/başlangıç/i.test(a['Aktif faz'] ?? '')) parts.push(t(root, 'statusline.step', { step: a['Başlangıç adımı'] ?? '-' }));
+    else parts.push(a['Aktif görev'] ?? '-', t(root, 'statusline.task', { done: d.taskCount.done, total: d.taskCount.total }));
+    parts.push(t(root, 'statusline.question', { mode: question }));
+    if (d.pending.length) parts.push(t(root, 'statusline.pending', { count: d.pending.length }));
   }
   const limit = limitPart();
   if (limit) parts.push(limit);
-  if (context != null) parts.push(`bağlam %${context}${context >= 70 ? ' ⛔' : context >= 50 ? ' ⚠' : ''}`);
+  if (context != null) parts.push(t(root, 'statusline.context', { percent: context }) + (context >= 70 ? ' ⛔' : context >= 50 ? ' ⚠' : ''));
   console.log(parts.join(' · '));
 } catch {
-  console.log('▶ durum okunamadı');
+  console.log(t(root, 'statusline.unreadable'));
 }

package/.claude/hooks/structure-guard.mjs

@@ -8,6 +8,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 import { readInput, decide, findRoot, isMain } from './shared.mjs';
+import { t } from './lang.mjs';
 
 const root = findRoot();
 
@@ -41,14 +42,13 @@ export function check(rel, map) {
   if (rel.startsWith('sandbox/')) return null;
   const denied = map.deny.find((re) => re.test(rel));
   if (denied) {
-    return { decision: 'deny', reason: `"${rel}" dağınıklık kalıbına uyuyor (yedek, eski sürüm, kopya veya geçici dosya). Git geçmişi zaten yedektir; deneme için sandbox/ kullan.` };
+    return { decision: 'deny', reason: `"${rel}" matches a clutter pattern (backup, old version, copy or temp file). Git history is already the backup; use sandbox/ for experiments.` };
   }
   if (map.allow.some((re) => re.test(rel))) return null;
   const top = [...new Set((map.raw.allow ?? []).map((d) => d.split('/')[0]).filter((d) => !d.includes('.') || d.startsWith('.')))].slice(0, 12);
   return {
     decision: 'ask',
-    reason: `"${rel}" yapı haritasında yok (.claude/structure.json). Doğru yer muhtemelen şunlardan biri: ${top.join(', ')}. ` +
-      'Geçici veya deneme ise sandbox/ altına yaz. Kalıcı yeni bir yer gerekiyorsa bunu teknik karar olarak sor ve haritayı güncelle (docs/architecture/structure.md).',
+    reason: t(root, 'guard.structure.offMap', { rel, top: top.join(', ') }),
   };
 }
 
@@ -62,20 +62,20 @@ function hook() {
     const rel = path.relative(g.root, full);
     if (rel.startsWith('..') || path.isAbsolute(rel)) continue; // outside the project
     const s = check(rel, map);
-    if (s) decide(g.tool, s.decision, `Yapı: ${s.reason}`);
+    if (s) decide(g.tool, s.decision, s.decision === 'ask' ? t(g.root, 'guard.structure.prefix', { reason: s.reason }) : `Structure: ${s.reason}`);
   }
   process.exit(0);
 }
 
 function checkAll() {
   const map = readMap();
-  if (!map) { console.log('Yapı haritası yok (.claude/structure.json); kontrol atlandı.'); return; }
+  if (!map) { console.log('No structure map (.claude/structure.json); check skipped.'); return; }
   const files = execFileSync('git', ['ls-files'], { cwd: root, encoding: 'utf8' }).split('\n').filter(Boolean);
   const violations = files.map((f) => [f, check(f, map)]).filter(([, s]) => s);
-  if (!violations.length) { console.log(`Yapı uyumlu: ${files.length} dosya.`); return; }
-  console.error(`Yapı ihlali (${violations.length}):`);
-  for (const [f, s] of violations) console.error(`  ${s.decision === 'deny' ? 'YASAK' : 'HARİTA DIŞI'}  ${f}`);
-  console.error('Dosyayı doğru yere taşı, sandbox/ altına al veya haritayı (teknik kararla) güncelle.');
+  if (!violations.length) { console.log(`Structure OK: ${files.length} files.`); return; }
+  console.error(`Structure violations (${violations.length}):`);
+  for (const [f, s] of violations) console.error(`  ${s.decision === 'deny' ? 'FORBIDDEN' : 'OFF MAP'}  ${f}`);
+  console.error('Move the file to the right place, put it under sandbox/, or update the map (as a technical decision).');
   process.exit(1);
 }
 

package/.claude/hooks/test-guard.mjs

@@ -7,9 +7,12 @@
 //   test script) changes a field that could narrow the scope. A commented-out expectation counts as deleted.
 //   It does not block: the user approves a justified change.
 //   In Claude Code a test file can only be written by the test-writer subagent (agent_type); anyone else is denied.
+//   --record (PostToolUse): stores the digest of each test file test-writer wrote; commit-gate.mjs checks it.
 import fs from 'node:fs';
 import path from 'node:path';
-import { readInput, decide, isMain } from './shared.mjs';
+import crypto from 'node:crypto';
+import { readInput, decide, isMain, findRoot } from './shared.mjs';
+import { t } from './lang.mjs';
 
 const TEST = /(^|\/)(tests?|__tests__|e2e|spec)\/|\.(test|spec|e2e-spec)\.[cm]?[jt]sx?$|(^|\/)test_[^/]*\.py$|_test\.(py|go)$/i;
 // Windows resolves "a.test.ts.", "a.test.ts " and "a.test.ts::$DATA" (alternate stream) to the same file
@@ -35,9 +38,9 @@ const count = (s, re) => (stripComments(s).match(re) ?? []).length;
 
 // Returns: null (no problem) | a description of the weakening
 export function weakening(before, after) {
-  if (count(after, SKIP) > count(before, SKIP)) return 'test atlanıyor veya tek teste odaklanıyor (.skip / .only / skipIf / xit / pytest skip)';
-  if (count(after, EXPECT) < count(before, EXPECT)) return 'beklenti (expect/assert) siliniyor veya yoruma alınıyor';
-  if (count(after, WEAK) > count(before, WEAK)) return 'beklenti gevşetiliyor (toBeTruthy, toBeDefined, expect.anything, matcher\'sız expect, assert True)';
+  if (count(after, SKIP) > count(before, SKIP)) return t(findRoot(), 'guard.test.skip');
+  if (count(after, EXPECT) < count(before, EXPECT)) return t(findRoot(), 'guard.test.expectRemoved');
+  if (count(after, WEAK) > count(before, WEAK)) return t(findRoot(), 'guard.test.expectWeak');
   return null;
 }
 
@@ -45,9 +48,17 @@ export function weakening(before, after) {
 export function configRisk(before, after) {
   const a = new Set(before.split('\n')), b = new Set(after.split('\n'));
   const changed = [...a].filter((s) => !b.has(s)).concat([...b].filter((s) => !a.has(s)));
-  return changed.some((s) => RISKY.test(s)) ? 'testlerin kapsamını belirleyen ayar değişiyor (include/exclude, testMatch, passWithNoTests, eşik, test script\'i)' : null;
+  return changed.some((s) => RISKY.test(s)) ? t(findRoot(), 'guard.test.configRisk') : null;
 }
 
+// The real path too: a link or junction into the test folder, a Windows short name (TESTS~1)
+// A new nested path (lnk/new/sub/x.ts): resolve the nearest folder that exists and append the rest
+const realOf = (p) => {
+  for (let dir = p, rest = ''; ; rest = path.join(path.basename(dir), rest), dir = path.dirname(dir)) {
+    try { return path.join(fs.realpathSync.native(dir), rest); } catch { if (path.dirname(dir) === dir) return p; }
+  }
+};
+
 function hook() {
   const g = readInput();
   if (!g) process.exit(0);
@@ -56,13 +67,6 @@ function hook() {
     const rel = path.relative(g.root, full);
     return [full, rel.startsWith('..') || path.isAbsolute(rel) ? full : rel];
   };
-  // The real path too: a link or junction into the test folder, a Windows short name (TESTS~1)
-  // A new nested path (lnk/new/sub/x.ts): resolve the nearest folder that exists and append the rest
-  const realOf = (p) => {
-    for (let dir = p, rest = ''; ; rest = path.join(path.basename(dir), rest), dir = path.dirname(dir)) {
-      try { return path.join(fs.realpathSync.native(dir), rest); } catch { if (path.dirname(dir) === dir) return p; }
-    }
-  };
   for (const f of g.files) {
     if (!f.path) continue;
     const [full, name] = resolveName(f.path);
@@ -73,24 +77,61 @@ function hook() {
     // Tests are written by the test-writer agent only (AGENTS.md rule 7): whoever writes the code must not shape the test
     // to it. Only Claude Code reports the subagent; Codex and Antigravity keep the rule in text. Config files stay a question.
     if (g.tool === 'claude' && g.agent !== 'test-writer' && !config) {
-      decide(g.tool, 'deny', `Test ayrımı: ${name.split(path.sep).join('/')} bir test dosyası; test dosyalarına yalnız test-writer ajanı yazar, kodu yazan testi değiştiremez (AGENTS.md kural 7). ` +
-        'Test eklemek veya değiştirmek gerekiyorsa test-writer ajanını çağır (varsa SendMessage ile sürdür); kriter değişiyorsa kullanıcıya sor.');
+      decide(g.tool, 'deny', `Test separation: ${name.split(path.sep).join('/')} is a test file; only the test-writer agent writes test files, and whoever writes the code cannot change tests (AGENTS.md rule 7). ` +
+        'If a test must be added or changed, call the test-writer agent (continue it with SendMessage if it exists); if the criterion changes, ask the user.');
     }
     let before = f.before;
     if (before === undefined) { try { before = fs.readFileSync(full, 'utf8'); } catch { before = ''; } }
     const after = f.after ?? f.text;
     let reason;
-    if (f.deleted) reason = config ? 'test ayar dosyası siliniyor' : 'test dosyası siliniyor';
+    if (f.deleted) reason = t(g.root, config ? 'guard.test.configDeleted' : 'guard.test.fileDeleted');
     // Codex Move: a test moved to a path that does not run is as good as deleted; moving onto an existing file overwrites it
-    else if (source && (!isTestFile(name) || (TEST_NAME.test(path.basename(source)) && !TEST_NAME.test(path.basename(name))))) reason = `test dosyası çalışmayan bir yola taşınıyor (${f.source})`;
-    else if (f.source && fs.existsSync(full)) reason = `taşıma var olan dosyanın üstüne yazıyor (${f.source} → ${f.path})`;
+    else if (source && (!isTestFile(name) || (TEST_NAME.test(path.basename(source)) && !TEST_NAME.test(path.basename(name))))) reason = t(g.root, 'guard.test.movedAway', { source: f.source });
+    else if (f.source && fs.existsSync(full)) reason = t(g.root, 'guard.test.moveOverwrite', { source: f.source, path: f.path });
     else reason = config ? configRisk(before, after) : weakening(before, after);
     if (reason) {
-      decide(g.tool, 'ask', `Test koruması: ${name.split(path.sep).join('/')} içinde ${reason}. Testi geçirmek için testi zayıflatmak yasak (AGENTS.md kural 7). ` +
-        'Gerekçe gerçekse (yanlış test, değişen kabul kriteri) kullanıcıya söyle ve onayını al; değilse kodu düzelt.');
+      decide(g.tool, 'ask', t(g.root, 'guard.test.ask', { name: name.split(path.sep).join('/'), reason }));
+    }
+  }
+  process.exit(0);
+}
+
+// What test-writer wrote: the commit gate stops a changed test file whose content on disk is not one of these
+// (git apply, patch or a script writes past the PreToolUse guards). State: .claude/state/test-writer.json → { files: { path: digest } }
+export const digest = (buf) => crypto.createHash('sha256').update(buf).digest('hex').slice(0, 16);
+export const recordPath = (root) => path.join(root, '.claude', 'state', 'test-writer.json');
+export function readRecord(root) {
+  try {
+    const d = JSON.parse(fs.readFileSync(recordPath(root), 'utf8'));
+    return d?.files && typeof d.files === 'object' && !Array.isArray(d.files) ? d.files : {};
+  } catch { return {}; }
+}
+
+// PostToolUse: the file is on disk now, so its digest is what test-writer left
+function record() {
+  const g = readInput();
+  if (!g || g.tool !== 'claude' || g.agent !== 'test-writer') process.exit(0);
+  const files = readRecord(g.root);
+  const rootReal = realOf(g.root);
+  for (const f of g.files) {
+    if (!f.path) continue;
+    const full = path.resolve(g.dir, f.path);
+    let body;
+    try { body = fs.readFileSync(full); } catch { continue; }
+    // The written path and its real path (a link into the test folder): git lists the one it tracks
+    for (const rel of [path.relative(g.root, full), path.relative(rootReal, realOf(full))]) {
+      const key = rel.split(path.sep).join('/');
+      if (!key.startsWith('..') && !path.isAbsolute(rel) && isTestFile(key) && !isTestConfig(key)) files[key] = digest(body);
     }
   }
+  // Temp file + rename: a reader never sees half a JSON (it would read {} and drop every record)
+  const tmp = `${recordPath(g.root)}.${process.pid}.tmp`;
+  try {
+    fs.mkdirSync(path.dirname(tmp), { recursive: true });
+    fs.writeFileSync(tmp, JSON.stringify({ files }, null, 2));
+    fs.renameSync(tmp, recordPath(g.root));
+  } catch { fs.rmSync(tmp, { force: true }); /* the commit gate then asks for test-writer again */ }
   process.exit(0);
 }
 
-if (isMain(import.meta.url)) hook();
+if (isMain(import.meta.url)) (process.argv.includes('--record') ? record : hook)();

package/.claude/hooks/tools.mjs

@@ -17,41 +17,41 @@ import { findRoot, isMain } from './shared.mjs';
 // Keys are the package names users type (/tools ac tasarim): they stay Turkish
 export const PACKAGES = {
   tasarim: {
-    description: 'Stil yönleri, palet ve yazı tipi, GSAP',
+    description: 'Style directions, palette and typefaces, GSAP',
     command: '/design',
     plugins: ['taste-skill@taste-skill', 'ui-ux-pro-max@ui-ux-pro-max-skill', 'gsap-skills@gsap-skills'],
   },
   guvenlik: {
-    description: 'Derin güvenlik taraması',
+    description: 'Deep security scan',
     command: '/findings-security, /release',
     plugins: ['differential-review', 'insecure-defaults', 'sharp-edges', 'static-analysis', 'supply-chain-risk-auditor', 'agentic-actions-auditor', 'fp-check']
       .map((e) => `${e}@trailofbits`).concat('claude-security@claude-plugins-official'),
   },
   yayin: {
-    description: 'İnsan için kod haritası, oturum raporu',
+    description: 'Code map for humans, session report',
     command: '/release, /handoff, /adopt',
     plugins: ['understand-anything@understand-anything', 'session-report@claude-plugins-official'],
   },
-  video: { description: 'Remotion ile video', command: 'motion-video', plugins: ['remotion@remotion'] },
+  video: { description: 'Video with Remotion', command: 'motion-video', plugins: ['remotion@remotion'] },
 };
 
 // Command descriptions are also in the skill list. Light: non-core commands are listed by name only (skillOverrides "name-only"),
 // still in the / menu and callable by name. Kit settings.json ships this list; a test keeps the two in sync.
 export const CORE_COMMANDS = ['start', 'adopt', 'build', 'fix-bug', 'plan-task', 'design', 'tools', 'review-changes', 'wrap-up', 'release'];
 export const LIGHT_COMMANDS = ['ask-mode', 'board', 'dashboard', 'findings-all', 'findings-business', 'findings-legal', 'findings-perf',
-  'findings-security', 'findings-tech', 'findings-ux', 'freeze', 'handoff', 'kit-update', 'maintain', 'qa', 'research', 'retro', 'rollback', 'user-feedback'];
+  'findings-security', 'findings-tech', 'findings-ux', 'freeze', 'handoff', 'kit-update', 'language', 'maintain', 'qa', 'research', 'retro', 'rollback', 'user-feedback'];
 
 const settingsPaths = (root) => ({ project: path.join(root, '.claude', 'settings.json'), local: path.join(root, '.claude', 'settings.local.json') });
 
 function readJson(p) {
   if (!fs.existsSync(p)) return {};
   try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch {
-    throw new Error(`${p} geçerli JSON değil; düzeltmeden paket değiştirilemez.`);
+    throw new Error(`${p} is not valid JSON; fix it before changing a package.`);
   }
 }
 
 function pkg(name) {
-  if (!Object.hasOwn(PACKAGES, name ?? '')) throw new Error(`Bilinmeyen paket: ${name}. Seçenekler: ${Object.keys(PACKAGES).join(', ')}`);
+  if (!Object.hasOwn(PACKAGES, name ?? '')) throw new Error(`Unknown package: ${name}. Options: ${Object.keys(PACKAGES).join(', ')}`);
   return PACKAGES[name];
 }
 
@@ -84,12 +84,12 @@ export function setPackage(root, name, enabled) {
 // Writes the shared project settings (the profile is team-wide). Only kit light commands without a value change; the user's
 // own values (another skill, or "on"/"off" on a kit command) stay. full keeps an empty key so the update does not add the list back.
 export function setCommandMode(root, mode) {
-  if (mode !== 'light' && mode !== 'full') throw new Error(`Bilinmeyen mod: ${mode}. Seçenekler: light, full`);
+  if (mode !== 'light' && mode !== 'full') throw new Error(`Unknown mode: ${mode}. Options: light, full`);
   const file = settingsPaths(root).project;
-  if (!fs.existsSync(file)) throw new Error(`${file} yok; komut listesi yazılmadı.`);
+  if (!fs.existsSync(file)) throw new Error(`${file} does not exist; the command list was not written.`);
   const s = readJson(file);
   const isObject = (x) => x && typeof x === 'object' && !Array.isArray(x);
-  if (!isObject(s) || (s.skillOverrides !== undefined && !isObject(s.skillOverrides))) throw new Error(`${file} → skillOverrides bir nesne değil; düzeltmeden yazılmaz.`);
+  if (!isObject(s) || (s.skillOverrides !== undefined && !isObject(s.skillOverrides))) throw new Error(`${file} → skillOverrides is not an object; fix it before writing.`);
   const o = { ...(s.skillOverrides ?? {}) };
   for (const c of LIGHT_COMMANDS) {
     if (mode === 'light' && o[c] === undefined) o[c] = 'name-only';
@@ -139,57 +139,56 @@ export function measure() {
 const installedList = () => Object.entries(installRecords()).flatMap(([id, k]) => [k].flat().map((e) => ({ id, scope: e?.scope, projectPath: e?.projectPath })));
 const tokenOf = (measurement, ids) => {
   const found = measurement.filter((o) => ids.includes(o.id));
-  return found.length ? `~${found.reduce((s, o) => s + o.skillTokens + o.agentTokens, 0)} token` : '? token (kurulu değil)';
+  return found.length ? `~${found.reduce((s, o) => s + o.skillTokens + o.agentTokens, 0)} token` : '? token (not installed)';
 };
-const NOTE = 'Açtıktan sonra /reload-plugins. Oturum ortasında açmak prompt önbelleğini bozar; en iyisi faz sınırında, /clear ile.';
+const NOTE = 'After enabling, run /reload-plugins. Enabling mid-session breaks the prompt cache; best at a phase boundary, together with /clear.';
 if (isMain(import.meta.url)) {
   const root = findRoot();
   const [flag, name] = process.argv.slice(2);
   try {
     if (flag === '--enable' || flag === '--disable') {
       const ids = setPackage(root, name, flag === '--enable');
-      if (!ids.length) { console.log(`${name} paketinin eklentisi bu projede tanımlı değil; değişiklik yok.`); process.exit(0); }
-      console.log(`${name} paketi ${flag === '--enable' ? 'açıldı' : 'proje varsayılanına döndü'} (.claude/settings.local.json): ${ids.join(', ')}`);
+      if (!ids.length) { console.log(`The plugins of package ${name} are not defined in this project; no change.`); process.exit(0); }
+      console.log(`Package ${name} ${flag === '--enable' ? 'enabled' : 'back to the project default'} (.claude/settings.local.json): ${ids.join(', ')}`);
       const missing = missingPlugins(Object.fromEntries(ids.map((id) => [id, true])), installedList(), root).map((e) => e.id);
-      if (flag === '--enable' && missing.length) console.log(`Kurulu değil: ${missing.join(', ')}. Kullanıcıya sor, onaylarsa: node .claude/hooks/plugins-sync.mjs --install`);
+      if (flag === '--enable' && missing.length) console.log(`Not installed: ${missing.join(', ')}. Ask the user; if they approve: node .claude/hooks/plugins-sync.mjs --install`);
       console.log(NOTE);
     } else if (flag === '--required') {
       pkg(name);
       const d = packageStatus(root).find((x) => x.name === name);
-      if (!d.plugins.length) { console.log(`${name} paketi bu projede yok; adımı atla.`); process.exit(0); }
-      if (d.enabled) { console.log(`${name} paketi açık.`); process.exit(0); }
-      console.log(`${name} paketi kapalı (${tokenOf(measure(), d.plugins)}/oturum: ${d.plugins.join(', ')}). ` +
-        `Kullanıcıya sor; onaylarsa: node .claude/hooks/tools.mjs --enable ${name}, sonra /reload-plugins. Reddederse adımı paketsiz yap.`);
+      if (!d.plugins.length) { console.log(`Package ${name} is not in this project; skip the step.`); process.exit(0); }
+      if (d.enabled) { console.log(`Package ${name} is enabled.`); process.exit(0); }
+      console.log(`Package ${name} is disabled (${tokenOf(measure(), d.plugins)}/session: ${d.plugins.join(', ')}). ` +
+        `Ask the user; if they approve: node .claude/hooks/tools.mjs --enable ${name}, then /reload-plugins. If they decline, do the step without the package.`);
       process.exit(2);
     } else if (flag === '--measure') {
       const project = readJson(settingsPaths(root).project).enabledPlugins ?? {};
       const effective = { ...project, ...(readJson(settingsPaths(root).local).enabledPlugins ?? {}) };
-      const packageOf = (id) => Object.keys(PACKAGES).find((a) => PACKAGES[a].plugins.includes(id)) ?? (id in project ? 'çekirdek' : '-');
+      const packageOf = (id) => Object.keys(PACKAGES).find((a) => PACKAGES[a].plugins.includes(id)) ?? (id in project ? 'core' : '-');
       const rows = measure().map((o) => ({ plugin: o.id, pkg: packageOf(o.id), enabled: effective[o.id] === true, skill: o.skill, descTokens: o.skillTokens, agentTokens: o.agentTokens }))
         .sort((a, b) => b.descTokens + b.agentTokens - a.descTokens - a.agentTokens);
-      // Table headers are shown to the user: Turkish
-      console.table(rows.map((r) => ({ eklenti: r.plugin, paket: r.pkg, açık: r.enabled, skill: r.skill, açıklamaTok: r.descTokens, ajanTok: r.agentTokens })));
+      console.table(rows.map((r) => ({ plugin: r.plugin, package: r.pkg, enabled: r.enabled, skill: r.skill, descTokens: r.descTokens, agentTokens: r.agentTokens })));
       const top = (l) => l.reduce((s, r) => s + r.descTokens + r.agentTokens, 0);
-      console.log(`Açık eklentiler: ~${top(rows.filter((r) => r.enabled))} token · hepsi açık olsaydı: ~${top(rows)} token. Kesin değer: /context, /doctor.`);
+      console.log(`Enabled plugins: ~${top(rows.filter((r) => r.enabled))} tokens · if all were enabled: ~${top(rows)} tokens. Exact value: /context, /doctor.`);
     } else if (flag === '--commands') {
       setCommandMode(root, name);
       console.log(name === 'light'
-        ? `Komut listesi hafif: ${LIGHT_COMMANDS.length} komut sadece adıyla listelenir (/ menüsünde durur). Yeni oturumda geçerli.`
-        : 'Komut listesi tam: bütün komutlar açıklamasıyla listelenir. Yeni oturumda geçerli.');
+        ? `Command list is light: ${LIGHT_COMMANDS.length} commands are listed by name only (they stay in the / menu). Takes effect in a new session.`
+        : 'Command list is full: all commands are listed with their descriptions. Takes effect in a new session.');
     } else if (!flag) {
       const state = packageStatus(root);
       const project = readJson(settingsPaths(root).project).enabledPlugins ?? {};
       const packaged = new Set(Object.values(PACKAGES).flatMap((p) => p.plugins));
-      console.log(`Çekirdek (hep açık): ${Object.keys(project).filter((id) => project[id] !== false && !packaged.has(id)).join(', ') || '-'}`);
+      console.log(`Core (always on): ${Object.keys(project).filter((id) => project[id] !== false && !packaged.has(id)).join(', ') || '-'}`);
       const measurement = measure();
       for (const d of state.filter((x) => x.plugins.length)) {
-        console.log(`  ${d.name.padEnd(9)} ${d.enabled ? 'açık  ' : 'kapalı'}  ${tokenOf(measurement, d.plugins).padEnd(24)} ${d.command} · ${d.description}`);
+        console.log(`  ${d.name.padEnd(9)} ${d.enabled ? 'on ' : 'off'}  ${tokenOf(measurement, d.plugins).padEnd(24)} ${d.command} · ${d.description}`);
       }
       const cm = commandMode(root);
-      console.log(`Komut listesi: ${{ light: 'hafif', full: 'tam', mixed: 'karışık' }[cm.mode]} (${cm.named}/${LIGHT_COMMANDS.length} komut sadece adıyla; değiştirmek: --commands light|full)`);
+      console.log(`Command list: ${cm.mode} (${cm.named}/${LIGHT_COMMANDS.length} commands by name only; to change: --commands light|full)`);
       console.log(NOTE);
     } else {
-      console.error('Kullanım: tools.mjs [--enable <paket> | --disable <paket> | --required <paket> | --measure | --commands light|full]');
+      console.error('Usage: tools.mjs [--enable <package> | --disable <package> | --required <package> | --measure | --commands light|full]');
       process.exit(1);
     }
   } catch (h) {

package/.claude/hooks/usage.mjs

@@ -7,11 +7,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { findRoot, isMain } from './shared.mjs';
+import { t, readLang } from './lang.mjs';
 
 export const THRESHOLDS = { five_hour: { yellow: 60, red: 85 }, seven_day: { yellow: 70, red: 90 } };
-const WINDOWS = { five_hour: '5 saatlik', seven_day: 'haftalık' };
-// Level shown to the user
-export const LEVEL_LABEL = { green: 'yeşil', yellow: 'sarı', red: 'kırmızı', unknown: 'bilinmiyor' };
+// Window → message key of its name
+const WINDOWS = { five_hour: 'usage.window5h', seven_day: 'usage.windowWeek' };
+// Plain level names (flow.mjs, read by the AI); summary() shows them in the project language through usage.level.* keys
+export const LEVEL_LABEL = { green: 'green', yellow: 'yellow', red: 'red', unknown: 'unknown' };
 const file = (root) => path.join(root, '.claude', 'state', 'usage.json');
 
 export function writeLimits(root, rateLimits, now = Date.now()) {
@@ -50,7 +52,7 @@ export function readLimits(root, now = Date.now()) {
   return data;
 }
 
-// green | yellow | red | unknown (LEVEL_LABEL has the Turkish label)
+// green | yellow | red | unknown (LEVEL_LABEL has the plain label)
 export function level(data) {
   if (!data) return 'unknown';
   let s = 'green';
@@ -63,23 +65,24 @@ export function level(data) {
   return s;
 }
 
-function timeLeft(resetsAt, now) {
+function timeLeft(resetsAt, now, root) {
   if (!resetsAt) return '';
   const min = Math.max(0, Math.round((resetsAt * 1000 - now) / 60000));
-  const clock = new Date(resetsAt * 1000).toLocaleString('tr-TR', { day: '2-digit', month: '2-digit', hour: '2-digit', minute: '2-digit' });
-  const left = min >= 1440 ? `${Math.floor(min / 1440)} gün ${Math.floor((min % 1440) / 60)} sa` : `${Math.floor(min / 60)} sa ${min % 60} dk`;
-  return `sıfırlanma ${clock}, ${left} sonra`;
+  const clock = new Date(resetsAt * 1000).toLocaleString(readLang(root) === 'tr' ? 'tr-TR' : 'en-GB', { day: '2-digit', month: '2-digit', hour: '2-digit', minute: '2-digit' });
+  const left = min >= 1440
+    ? t(root, 'usage.leftDays', { days: Math.floor(min / 1440), hours: Math.floor((min % 1440) / 60) })
+    : t(root, 'usage.leftHours', { hours: Math.floor(min / 60), minutes: min % 60 });
+  return t(root, 'usage.resets', { clock, left });
 }
 
-export function summary(data, now = Date.now()) {
-  if (!data) {
-    return 'Limit bilgisi yok. Masaüstü uygulamasındaysan get_usage aracını kullan. Terminal/IDE\'de durum çubuğu ilk API yanıtından sonra yazar. İkisi de yoksa kullanıcıdan /usage sonucunu iste.';
-  }
+// The dashboard shows this text to the user, so it follows the project language (root)
+export function summary(data, now = Date.now(), root = findRoot()) {
+  if (!data) return t(root, 'usage.none');
   const parts = Object.entries(WINDOWS)
     .filter(([k]) => data[k])
-    .map(([k, name]) => `${name}: %${Math.round(data[k].percent)}${data[k].renewed ? ' (yenilendi)' : ` (${timeLeft(data[k].resetsAt, now)})`}`);
-  const stale = data.ageMin > 30 ? ' — eski olabilir, get_usage veya /usage ile doğrula' : '';
-  return `${parts.join(' · ')} · seviye: ${LEVEL_LABEL[level(data)]} · ${data.ageMin} dk önce okundu${stale}`;
+    .map(([k, name]) => t(root, 'usage.windowPart', { name: t(root, name), percent: Math.round(data[k].percent), tail: data[k].renewed ? ` ${t(root, 'usage.renewed')}` : ` (${timeLeft(data[k].resetsAt, now, root)})` }));
+  const stale = data.ageMin > 30 ? t(root, 'usage.stale') : '';
+  return t(root, 'usage.summary', { parts: parts.join(' · '), level: t(root, `usage.level.${level(data)}`), age: data.ageMin, stale });
 }
 
 if (isMain(import.meta.url)) {

package/.claude/output-styles/anlatici.md

@@ -1,47 +1,47 @@
 ---
 name: anlatici
-description: Anlatıcı mod. Her değişikliği ve hatayı yazılım bilmeyen birine anlatır gibi sade Türkçe ile açıklar. Kod yazma davranışı değişmez.
+description: Narrator mode. Explains every change and error in plain language in the conversation language, as if to someone who knows no software. Coding behavior does not change.
 keep-coding-instructions: true
 ---
 
-# Anlatıcı mod
+# Narrator mode
 
-Kullanıcı yazılım bilmiyor veya yeni öğreniyor. İşi her zamanki gibi yap; ama yaptığını, kullanıcının anlayacağı ve gerekirse başkasına anlatabileceği şekilde açıkla. Açıklamaları sade Türkçe ve tam cümleyle yaz. Rapor dili kısaltma kuralları (caveman) bu açıklamalara uygulanmaz; sadece durum bloğuna uygulanır.
+The user knows no software or is just learning. Do the work as usual, but explain what you did so the user understands it and can explain it to someone else if needed. Write explanations in plain language in the conversation language, in full sentences. The report language shortening rules (caveman) do not apply to these explanations; they apply only to the status block.
 
-## Her iş adımından sonra
+## After every work step
 
-Kod veya ayar değiştirdiysen, cevabın sonunda (durum bloğundan önce) şu bloğu yaz:
+If you changed code or settings, write this block at the end of your answer (before the status block):
 
 ```
-── Ne oldu? ─────────────────────
-Ne yaptım: <günlük dille 1-2 cümle; dosya adı yerine ne işe yaradığı: "kayıt formu", "giriş sayfası">
-Neden: <bu olmasaydı kullanıcının ne sorunu olurdu>
-Sen nasıl görürsün: <tıklanacak yer, açılacak sayfa veya çalıştırılacak tek komut>
-Yeni kavram: <bu adımda ilk kez geçen teknik terim varsa: "terim: tek cümlelik açıklama"; yoksa satırı yazma>
+── What happened? ───────────────
+What I did: <1-2 sentences in everyday language; say what a file is for, not its name: "sign-up form", "login page">
+Why: <what problem the user would have had without it>
+How you see it: <the place to click, the page to open or the single command to run>
+New concept: <a technical term that appears for the first time in this step: "term: one-sentence explanation"; leave the line out if there is none>
 ```
 
-## Görev sonunda anlama kontrolü
+## Understanding check at the end of a task
 
-`/build` veya `/fix-bug` raporundan sonra (durum bloğundan önce) bu görevdeki değişiklik hakkında en fazla 2 soru sor. Amaç sınav yapmak değil, kullanıcının neyin neden yapıldığını anlaması.
+After the `/build` or `/fix-bug` report (before the status block), ask at most 2 questions about the change in this task. The goal is not to give an exam but for the user to understand what was done and why.
 
-- AskUserQuestion ile sor. 3 seçenek koy: biri doğru, ikisi akla yatkın ama yanlış. Doğru seçeneğin sırasını değiştir ve "(Önerilen)" yazma. Son seçenek "Şimdi değil" olsun.
-- Soru "Bu değişiklik neden gerekiyordu?" veya "Bu olmasaydı ne olurdu?" türünden olsun. Dosya adı ya da kod ayrıntısı sorma.
-- Doğru cevaba tek cümleyle karşılık ver. Yanlış cevapta doğrusunu 1-2 cümleyle anlat, yanlışı büyütme.
-- Cevaplanan her soruyu `docs/workflow/learning.md` → "Kayıtlar" tablosuna bir satır olarak ekle: `| YYYY-AA-GG | <görev kodu> | <kavram, 1-3 kelime> | doğru |` (ya da `yanlış`). "Şimdi değil" ve cevapsız soruları yazma. Dosya yoksa aynı başlık ve sütunlarla oluştur.
+- Ask with AskUserQuestion. Give 3 options: one correct, two plausible but wrong. Shuffle the position of the correct option and do not write "(Recommended)". Make the last option "Not now".
+- Make the question of the type "Why was this change needed?" or "What would happen without it?". Do not ask about file names or code details.
+- Respond to a correct answer in one sentence. For a wrong answer, explain the correct one in 1-2 sentences and do not make a big deal of the mistake.
+- Add every answered question as one row to the "Kayıtlar" table in `docs/workflow/learning.md`: `| YYYY-AA-GG | <task id> | <concept, 1-3 words> | doğru |` (or `yanlış`). Do not write "Not now" and unanswered questions. If the file does not exist, create it with the same heading and columns.
 
-## Hata olduğunda
+## When an error occurs
 
-Hata mesajını olduğu gibi kopyalama. Şöyle anlat:
+Do not copy the error message as it is. Explain it like this:
 
-1. **Ne oldu:** Hatanın günlük dildeki karşılığı. Örnek: "Uygulama veritabanına bağlanamadı, çünkü bağlantı adresi eksik."
-2. **Senin hatan mı:** Kullanıcının bir şey yapması gerekiyor mu, yoksa düzeltmeyi sen mi yapacaksın?
-3. **Ne yapıyoruz:** Düzeltme adımı. Kullanıcının yapması gereken bir şey varsa (panelden ayar, şifre girmek) adım adım ve tek tek yaz.
+1. **What happened:** The everyday-language equivalent of the error. Example: "The app could not connect to the database because the connection address is missing."
+2. **Is it your fault:** Does the user need to do something, or will you make the fix?
+3. **What we do:** The fix step. If the user has to do something (a setting in a panel, entering a password), write it step by step, one at a time.
 
-## Kurallar
+## Rules
 
-- Teknik terimi ilk kullandığında tek cümleyle açıkla. Örnek: "commit, yaptığımız değişikliklerin kaydedilmiş bir fotoğrafıdır". Sonraki kullanımlarda tekrar açıklama.
-- Benzetme kullanabilirsin, ama yanlış anlamaya yol açacak kadar basitleştirme.
-- Karar sorarken (AskUserQuestion) her seçeneğin açıklamasında "bunu seçersen ne değişir" kısmını teknik olmayan dille yaz.
-- Uzun açıklama yapma: Her blok en fazla 4-5 satır olsun. Kullanıcı daha fazlasını isterse detaya gir.
-- Kullanıcının bir şeyi bilmemesini eksiklik gibi gösterme. "Bunu zaten biliyorsundur" gibi ifadeler kullanma.
-- Bir şey bozulursa son çalışan hale dönme yolunu hatırlat: `/rollback`.
+- Explain a technical term in one sentence the first time you use it. Example: "a commit is a saved snapshot of the changes we made". Do not explain it again on later uses.
+- You may use analogies, but do not simplify so much that it leads to misunderstanding.
+- When asking for a decision (AskUserQuestion), write the "what changes if you choose this" part of each option's description in non-technical language.
+- Do not explain at length: each block is 4-5 lines at most. If the user wants more, go into detail.
+- Do not present not knowing something as a shortcoming. Do not use phrases like "you probably know this already".
+- If something breaks, remind the user of the way back to the last working state: `/rollback`.

package/.claude/security-patterns.json

@@ -4,17 +4,17 @@
       "rule_name": "supabase_service_role_client",
       "regex": "(service_role|SUPABASE_SERVICE_ROLE|SUPABASE_SECRET_KEY|sb_secret_)",
       "paths": ["**/src/app/**/*.tsx", "**/src/components/**", "**/src/features/**/components/**", "**/app/**/*.tsx"],
-      "reminder": "Supabase gizli anahtarı (sb_secret_…, eski service_role) istemci koduna girmez; RLS'yi atlar. Sunucu tarafına (server action, route handler, edge function) taşı."
+      "reminder": "The Supabase secret key (sb_secret_…, the old service_role) must not go into client code; it bypasses RLS. Move it to the server side (server action, route handler, edge function)."
     },
     {
       "rule_name": "public_env_secret",
       "regex": "(NEXT_PUBLIC|EXPO_PUBLIC)_[A-Z_]*(SECRET|SERVICE_ROLE|PRIVATE)",
-      "reminder": "NEXT_PUBLIC_ / EXPO_PUBLIC_ değişkenleri tarayıcıya ve uygulama paketine gömülür. Gizli değer bu önekle tanımlanmaz."
+      "reminder": "NEXT_PUBLIC_ / EXPO_PUBLIC_ variables are embedded in the browser and the app bundle. Never define a secret value with this prefix."
     },
     {
       "rule_name": "personal_data_log",
       "regex": "console\\.(log|info)\\([^)]*(email|phone|tckn|tc_kimlik|password|token)",
-      "reminder": "Kişisel veri veya kimlik bilgisi loglanmaz (KVKK). Kimliği maskele veya sadece kayıt id'sini yaz."
+      "reminder": "Do not log personal data or credentials (KVKK, the Turkish data protection law). Mask the identity or log only the record id."
     }
   ]
 }