tillerhand 3.48.1 → 3.49.1

package/.claude/hooks/dashboard.mjs

@@ -11,8 +11,7 @@ import { verdict, isValue } from './labels.mjs';
 import { readLimits, summary, level, THRESHOLDS } from './usage.mjs';
 import { packageStatus, commandMode } from './tools.mjs';
 import { readModels, modelsFile, modelsNote, roleLabel } from './models.mjs';
-import { OLD_SIZES } from './progress.mjs';
-import { readLang, t } from './lang.mjs';
+import { readLang, t, locale } from './lang.mjs';
 import { acceptanceStatus, accounts, flags, unitEconomics, feedback, learning, qaSummary, metrics, githubStatus, readContext, findingReports, FINDING_KINDS, producedAssets, costSummary, councilMinutes, spendAlarms, envWarnings, repeatedBugClasses } from './dashboard-data.mjs';
 
 const args = process.argv.slice(2);
@@ -28,8 +27,8 @@ const kindName = (k) => (Object.hasOwn(FINDING_KINDS, k) ? L(`dashboard.findingK
 // The dashboard is made in the user's language: none before /start or /adopt asks it
 const lang = readLang(root);
 if (!lang) { if (!quiet) console.log('No language chosen yet: the dashboard is made after /start or /adopt asks it.'); process.exit(0); }
-// Dates follow the conversation language (English when the runtime does not know the code)
-const loc = (() => { try { return Intl.DateTimeFormat.supportedLocalesOf(lang)[0] ?? 'en'; } catch { return 'en'; } })();
+// Dates follow the conversation language
+const loc = locale(lang);
 
 // ---------- data ----------
 const d = readStatus(root);
@@ -119,6 +118,8 @@ if (d.kitPending) addAlert('info', L('dashboard.alert.kitPending'), L('dashboard
 if (d.handoffPending) addAlert('warn', L('dashboard.alert.handoffPending'), '/handoff take');
 const lastReject = [...d.board.meetings].reverse().find((t) => verdict(t.result) === 'reject');
 if (lastReject && !lastReject.decision) addAlert('critical', L('dashboard.alert.boardReject', { kind: lastReject.kind, scope: lastReject.scope, critical: lastReject.critical || L('dashboard.criticalFinding') }), L('dashboard.act.askClaudeFix'));
+// A result verdict() cannot read is not an approval: the user checks it (fail-closed)
+for (const t of d.board.meetings.filter((m) => m.result && verdict(m.result) === 'unknown')) addAlert('warn', L('dashboard.alert.unknownVerdict', { kind: t.kind, scope: t.scope, result: t.result }), 'docs/workflow/board.md');
 const limitLevel = level(limit);
 const limitShort = limit ? [[L('dashboard.limit5h'), limit.five_hour], [L('dashboard.limitWeeklyLower'), limit.seven_day]].filter(([, p]) => p)
   .map(([name, p]) => `${name} %${Math.round(p.percent)}${p.resetsAt ? ` ${L('dashboard.resetsParen', { when: new Date(p.resetsAt * 1000).toLocaleString(loc, { weekday: 'short', hour: '2-digit', minute: '2-digit' }) })}` : ''}`).join(', ') : '';
@@ -130,7 +131,7 @@ for (const s of d.issues.slice(0, 5)) addAlert('warn', L('dashboard.alert.openIs
 for (const r of repeatedBugClasses(root)) addAlert('info', L('dashboard.alert.repeatedBug', { count: r.specs.length, cls: r.cls, specs: r.specs.join(', ') }), '/retro');
 if (git?.changed.length > 15) addAlert('info', L('dashboard.alert.uncommitted', { count: git.changed.length }), L('dashboard.act.commitOrWrapUp'));
 if (git?.progressStale >= 3) addAlert('info', L('dashboard.alert.progressStale', { count: git.progressStale }), '/wrap-up');
-const off = (a['Question mode'] ?? '').match(/(?:kapalı konular|closed topics):\s*(.+)$/i)?.[1];
+const off = (a['Question mode'] ?? '').match(/closed topics:\s*(.+)$/i)?.[1];
 if (off && !isValue(off, 'none')) addAlert('info', L('dashboard.alert.closedTopics', { topics: off }), L('dashboard.act.askModeOpen'));
 if (d.installed && isValue(d.board.state, 'notSetUp') && !isValue(a['Active phase'], 'setup')) addAlert('info', L('dashboard.alert.boardNotSetUp'), '/board setup');
 if (github?.liveMonitoring?.length) addAlert('critical', L('dashboard.alert.liveMonitoring', { title: github.liveMonitoring[0].title }), L('dashboard.act.fixLive', { number: github.liveMonitoring[0].number }));
@@ -186,7 +187,7 @@ const autoDecisions = d.decisions.filter((k) => isValue(k.decidedBy, 'automatic'
 const rejectCount = d.board.meetings.filter((t) => verdict(t.result) === 'reject').length;
 const mvpCriteria = mvp.reduce((t, o) => ({ done: t.done + o.done, total: t.total + o.total }), { done: 0, total: 0 });
 const avgCost = Object.entries(cost.reduce((m, r) => {
-  if (!Number.isNaN(r.diff)) (m[OLD_SIZES[r.size] ?? r.size] ??= []).push(r.diff);
+  if (!Number.isNaN(r.diff)) (m[r.size] ??= []).push(r.diff);
   return m;
 }, Object.create(null))).map(([size, l]) => ({ size, avg: l.reduce((t, x) => t + x, 0) / l.length, n: l.length }));
 
@@ -202,25 +203,22 @@ const feedLabel = (k) => (Object.hasOwn(FEED_KEYS, k) ? L(FEED_KEYS[k]) : k);
 const onOff = (v) => (isValue(v, 'on') ? L('dashboard.on') : isValue(v, 'off') ? L('dashboard.off') : v);
 // A text for the page's own script: a single-quoted JS string, no tag can end the script block
 const jsStr = (key) => `'${L(key).replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/</g, '\\u003c')}'`;
-// A board verdict in either language; an option name (decision council) or an unreadable result is neutral
-const verdictBadge = (k) => badge({ approve: 'good', conditional: 'warn', reject: 'critical' }[verdict(k)] ?? 'info', k);
+// A council decision: an option name or an unreadable result is neutral. A meeting result verdict() cannot read is a warning.
+const verdictBadge = (k, other = 'info') => badge({ approve: 'good', conditional: 'warn', reject: 'critical' }[verdict(k)] ?? other, k);
 const badge = (sev, caption) => `<span class="badge ${sev}"><span class="ic" aria-hidden="true">${SEV[sev][0]}</span> ${e(caption ?? L(SEV[sev][1]))}</span>`;
 const fmtDate = (t) => { const z = toDate(t); return Number.isNaN(z.getTime()) ? e(t) : z.toLocaleString(loc, { day: '2-digit', month: 'short', hour: t.length > 10 ? '2-digit' : undefined, minute: t.length > 10 ? '2-digit' : undefined }); };
 const limitSeverity = (p, k) => (p == null ? 'info' : p >= THRESHOLDS[k].red ? 'critical' : p >= THRESHOLDS[k].yellow ? 'warn' : 'good');
 const TOPICS = ['product', 'tech', 'design', 'content', 'data', 'security', 'cost'];
-// Decision log topics before 3.48, in the same order; they count under the English topic
-const TOPICS_TR = ['urun', 'teknik', 'tasarim', 'icerik', 'veri', 'guvenlik', 'maliyet'];
-const topicKey = (topic = '') => { const k = topic.trim().toLowerCase(); return TOPICS[TOPICS_TR.indexOf(k)] ?? k; };
+const topicKey = (topic = '') => topic.trim().toLowerCase();
 
-// The command to paste into Claude: "`/build G-013` …" or "/wrap-up ve /clear" → first command, without its <placeholder> or note
-const cmdOf = (s = '') => { const m = String(s).match(/`(\/[^`\n]+)`/) ?? String(s).match(/^(\/.*)$/); return m ? m[1].split(/ ve | ile | and | to |\s*\(/)[0].replace(/\s*[[<].*$/, '').trim() : ''; };
+// The command to paste into Claude: "`/build G-013` …" or "/wrap-up and /clear" → first command, without its <placeholder> or note
+const cmdOf = (s = '') => { const m = String(s).match(/`(\/[^`\n]+)`/) ?? String(s).match(/^(\/.*)$/); return m ? m[1].split(/\s+\S+\s+\/[\w:-]+(?![\w:/-]|\.\w)| and | to |\s*\(/)[0].replace(/\s*[[<].*$/, '').trim() : ''; };
 const copyBtn = (s) => { const c = cmdOf(s); return c ? ` <button class="copy-cmd" type="button" data-cmd="${e(c)}" aria-label="${e(L('dashboard.copyAria', { command: c }))}">${e(L('dashboard.copy'))}</button>` : ''; };
 const alertRow = (x) => `<li class="${x.sev}"><span class="ic" aria-hidden="true">${SEV[x.sev][0]}</span><span><span class="sr-only">${L(SEV[x.sev][1])}: </span>${md(x.text)}</span>${x.action ? `<span class="action">→ ${md(x.action)}${copyBtn(x.action)}</span>` : ''}</li>`;
 const kpi = (label, value, sub = '', bar = '') => `<div class="kpi"><div class="kpi-l">${e(label)}</div><div class="kpi-v">${value}</div>${bar}<div class="kpi-s">${sub}</div></div>`;
 
 // ---------- sections ----------
-// A pre-3.48 value says "Faz 1"; the roadmap headings are read as "Phase 1"
-const activePhase = (a['Active phase'] ?? '').replace(/^faz\b/i, 'Phase').replace(/^başlangıç(?![\p{L}\p{N}])/iu, 'Setup');
+const activePhase = a['Active phase'] ?? '';
 const activeIndex = Math.max(0, [{ name: 'Setup' }, ...d.phases].findIndex((f) => activePhase.toLowerCase().startsWith(f.name.toLowerCase().split(' ').slice(0, 2).join(' '))));
 const start = (a['Setup step'] ?? '0/9').split('/').map(Number);
 const stageStrip = `<ol class="steps">${[{ name: 'Setup', done: start[0] || 0, total: start[1] || 9 }, ...d.phases].map((f, i) =>
@@ -264,7 +262,7 @@ const boardSection = `
   <div class="tw"><table><thead><tr><th>${L('dashboard.th.date')}</th><th>${L('dashboard.th.kind')}</th><th>${L('dashboard.th.topic')}</th><th>${L('dashboard.th.decision')}</th><th>${L('dashboard.th.consensus')}</th><th>${L('dashboard.th.minutes')}</th></tr></thead><tbody>${councils.slice(0, 10).map((k) => `<tr><td class="num nw">${e(k.date)}</td><td>${e(k.kind)}</td><td>${md(k.topic)}</td><td>${decisionBadge(k.decision)}</td><td class="num">${k.consensus == null ? '-' : `%${k.consensus}`}</td><td><a href="${k.file.split('/').map(encodeURIComponent).join('/')}" target="_blank" rel="noopener">${L('dashboard.open')}</a></td></tr>`).join('')}</tbody></table></div>`;
 })() : empty(L('dashboard.noCouncil'), '/board council <question>')}</section>
 <section class="card"><h3>${L('dashboard.meetingLog')}</h3>${d.board.meetings.length ? `<div class="tw"><table><thead><tr><th>#</th><th>${L('dashboard.th.date')}</th><th>${L('dashboard.th.kind')}</th><th>${L('dashboard.th.scope')}</th><th>${L('dashboard.th.attendees')}</th><th>${L('dashboard.th.result')}</th><th>${L('dashboard.th.critical')}</th><th>${L('dashboard.th.userDecision')}</th></tr></thead><tbody>
-${[...d.board.meetings].reverse().map((t) => `<tr><td class="num">${e(t.no)}</td><td class="num nw">${e(t.date)}</td><td>${e(t.kind)}</td><td>${md(t.scope)}</td><td>${e(t.attendees)}</td><td>${verdictBadge(t.result)}</td><td>${md(t.critical)}</td><td>${md(t.decision)}</td></tr>`).join('')}
+${[...d.board.meetings].reverse().map((t) => `<tr><td class="num">${e(t.no)}</td><td class="num nw">${e(t.date)}</td><td>${e(t.kind)}</td><td>${md(t.scope)}</td><td>${e(t.attendees)}</td><td>${verdictBadge(t.result, 'warn')}</td><td>${md(t.critical)}</td><td>${md(t.decision)}</td></tr>`).join('')}
 </tbody></table></div>` : empty(L('dashboard.noMeetings'))}</section>`;
 
 const quality = `
@@ -278,7 +276,7 @@ const quality = `
 ${qa ? `<section class="card"><h3>${L('dashboard.lastQa', { name: e(qa.name) })}</h3><div class="kpis mini">${kpi(L('dashboard.passed'), qa.passed)}${kpi(L('dashboard.failed'), qa.failed, qa.failed ? badge('critical', L('dashboard.withEvidence')) : '')}${kpi(L('dashboard.notRun'), qa.notRun)}</div>${qa.failures.length ? `<ul>${qa.failures.slice(0, 5).map((x) => `<li>${md(x.criterion)}${x.note ? ` <span class="muted small">${e(x.note)}</span>` : ''}</li>`).join('')}</ul>` : ''}<p class="muted small"><a href="${e(qa.file)}" target="_blank" rel="noopener">${L('dashboard.openReport')}</a></p></section>` : ''}
 <section class="card"><h3>${L('dashboard.acceptanceTests')}</h3>${acceptance.total ? `<div class="kpis mini">${kpi(L('dashboard.th.criterion'), acceptance.total)}${kpi(L('dashboard.kpiTested'), `${acceptance.tested}/${acceptance.total}`, '', progressBar(acceptance.tested, acceptance.total))}${kpi(L('dashboard.kpiPassing'), `${acceptance.passing}/${acceptance.total}`, acceptance.reportTime ? L('dashboard.reportTime', { when: new Date(acceptance.reportTime).toLocaleString(loc, { day: '2-digit', month: 'short', hour: '2-digit', minute: '2-digit' }) }) : L('dashboard.noJunit'), progressBar(acceptance.passing, acceptance.total, 'good'))}</div>` : empty(L('dashboard.noAcceptanceIds'))}</section>
 <section class="card"><h3>${L('dashboard.metricsMonthly')}</h3>${metricRecords.length ? `<div class="tw"><table><thead><tr><th>${L('dashboard.th.period')}</th><th>${L('dashboard.th.task')}</th><th>${L('dashboard.th.avgMinutes')}</th><th>${L('dashboard.th.avgLimit')}</th><th>${L('dashboard.th.fixes')}</th><th>${L('dashboard.th.reverts')}</th><th>${L('dashboard.th.duplicateCode')}</th><th>${L('dashboard.th.openCritical')}</th><th>${L('dashboard.th.acceptance')}</th></tr></thead><tbody>${[...metricRecords].reverse().slice(0, 8).map((m) => `<tr><td class="nw">${e(m.period)}</td><td class="num">${e(m.taskCount)}</td><td class="num">${e(m.duration)}</td><td class="num">${e(m.limit)}</td><td class="num">${e(m.fixes)}</td><td class="num">${e(m.reverts)}</td><td class="num">${e(m.duplicates)}</td><td class="num">${e(m.critical)}</td><td class="num">${e(m.acceptance)}</td></tr>`).join('')}</tbody></table></div>` : empty(L('dashboard.noMetrics'))}</section>
-<section class="card"><h3>${L('dashboard.criticalFlowTests')}</h3>${criticalFlows.length ? `<div class="tw"><table><thead><tr><th>#</th><th>${L('dashboard.th.flow')}</th><th>${L('dashboard.th.testKind')}</th><th>${L('dashboard.th.file')}</th><th>${L('dashboard.status')}</th></tr></thead><tbody>${criticalFlows.map((k) => `<tr><td class="num">${e(k.no)}</td><td>${md(k.feed)}</td><td>${e(k.kind)}</td><td>${md(k.fileName)}</td><td>${/✅|yeşil|var/i.test(k.state) ? badge('good', L('dashboard.present')) : badge('warn', L('dashboard.missing'))}</td></tr>`).join('')}</tbody></table></div>` : empty(L('dashboard.noTestPlan'))}</section>
+<section class="card"><h3>${L('dashboard.criticalFlowTests')}</h3>${criticalFlows.length ? `<div class="tw"><table><thead><tr><th>#</th><th>${L('dashboard.th.flow')}</th><th>${L('dashboard.th.testKind')}</th><th>${L('dashboard.th.file')}</th><th>${L('dashboard.status')}</th></tr></thead><tbody>${criticalFlows.map((k) => `<tr><td class="num">${e(k.no)}</td><td>${md(k.feed)}</td><td>${e(k.kind)}</td><td>${md(k.fileName)}</td><td>${/✅|green|present/i.test(k.state) ? badge('good', L('dashboard.present')) : badge('warn', L('dashboard.missing'))}</td></tr>`).join('')}</tbody></table></div>` : empty(L('dashboard.noTestPlan'))}</section>
 <section class="card"><h3>${L('dashboard.maintenanceLog')}</h3>${maintenance.length ? `<ul class="feed compact">${[...maintenance].reverse().slice(0, 8).map((b) => feedRow({ time: b.date, kind: 'maintenance', title: `${b.kind}: ${b.findings}`, extra: b.work })).join('')}</ul>` : empty(L('dashboard.noMaintenance'), '/maintain weekly')}
 ${lastRetro ? `<p class="muted small">${L('dashboard.lastRetro', { value: e(lastRetro) })}</p>` : ''}</section>`;
 
@@ -302,7 +300,7 @@ const product = `
 </div>
 <div class="grid2">
   <section class="card"><h3>${L('dashboard.technology')}</h3>${stack.length && !stack.every((s) => !s.choice) ? `<dl class="dl">${stack.map((s) => `<dt>${e(s.layer)}</dt><dd>${md(s.choice || '-')}</dd>`).join('')}</dl>` : empty(L('dashboard.noStack'))}</section>
-  <section class="card"><h3>${L('dashboard.design')}</h3>${designDirection.length ? `<dl class="dl">${designDirection.map((t) => `<dt>${e(t.area)}</dt><dd>${md(t.choice)}</dd>`).join('')}</dl>` : empty(L('dashboard.noDesign'), '/design genel')}
+  <section class="card"><h3>${L('dashboard.design')}</h3>${designDirection.length ? `<dl class="dl">${designDirection.map((t) => `<dt>${e(t.area)}</dt><dd>${md(t.choice)}</dd>`).join('')}</dl>` : empty(L('dashboard.noDesign'), '/design general')}
     ${previews.length ? `<h4>${L('dashboard.previews')}</h4><ul class="links">${previews.map((o) => `<li><b>${e(o.name)}</b> ${o.files.map((f) => `<a href=".previews/${encodeURIComponent(o.name)}/${encodeURIComponent(f)}" target="_blank" rel="noopener">${e(f.replace(/\.html$/, ''))}</a>`).join(' ')}</li>`).join('')}</ul>` : ''}</section>
 </div>
 <div class="grid2">
@@ -553,9 +551,9 @@ ${TABS.map(([id, , content], i) => `<div class="panel" role="tabpanel" id="p-${i
   });
 
   var auto = document.getElementById('auto-refresh'), timer;
-  try { auto.checked = localStorage.getItem('durum-oto') !== '0'; } catch (er) {}
+  try { auto.checked = localStorage.getItem('status-auto') !== '0'; } catch (er) {}
   function schedule() { clearTimeout(timer); if (auto.checked) timer = setTimeout(function () { location.reload(); }, 30000); }
-  auto.addEventListener('change', function () { try { localStorage.setItem('durum-oto', auto.checked ? '1' : '0'); } catch (er) {} schedule(); });
+  auto.addEventListener('change', function () { try { localStorage.setItem('status-auto', auto.checked ? '1' : '0'); } catch (er) {} schedule(); });
   schedule();
 })();
 </script>

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

@@ -218,7 +218,7 @@ export function scopeIssue(command, dir, root) {
   const vk = path.join(os.userInfo().homedir, '.vibe-kit');
   const touchesApproval = (y) => VIBE_KIT.test(y) || !/^\.\.|^$/.test(path.relative(y, vk)) && !path.isAbsolute(path.relative(y, vk));
   for (const h of targets) {
-    if (touchesApproval(h) || touchesApproval(realPath(h))) return { decision: 'ask', reason: /(preferences|tercihler)\.md$/i.test(h)
+    if (touchesApproval(h) || touchesApproval(realPath(h))) return { decision: 'ask', reason: /preferences[.]md$/i.test(h)
       ? t(root, 'guard.destructive.prefsFile', { path: h })
       : t(root, 'guard.destructive.gateApproval', { path: h }) };
     const rel = relPath(realPath(h), groot);
@@ -281,7 +281,7 @@ export const unquote = (s) => s.replace(/\$'((?:[^'\\]|\\.)*)'/g, '$1').replace(
 const RANK = { deny: 2, ask: 1 };
 const strictest = (...s) => s.filter(Boolean).sort((a, b) => RANK[b.decision] - RANK[a.decision])[0] ?? null;
 
-// A commit message that only names a command (git commit -m "commit-gate.mjs --skip anlatıldı") is text, not a call.
+// A commit message that only names a command (git commit -m "commit-gate.mjs --skip explained") is text, not a call.
 // Emptied only when the WHOLE command is one plain commit (optionally after "git add … &&") and the message is its last
 // word: then nothing else can hide in it. No quote, $, `, (, #, <, > before the message: a quote opened earlier
 // would make a real command look like the message. The message must be safe in bash, PowerShell and cmd alike: no

package/.claude/hooks/flow.mjs

@@ -23,7 +23,7 @@ const MEMBERS = [
   ['board-product', /^docs\/product\//i],
 ];
 // Auth, payment, webhook, upload, secrets: security-auditor joins on top of the member count (rules.md §3)
-const SENSITIVE = /auth|login|session|passw|payment|ödeme|checkout|billing|webhook|upload|secret|token|crypto|\.env|iyzico|paytr|stripe/i;
+const SENSITIVE = /auth|login|session|passw|payment|checkout|billing|webhook|upload|secret|token|crypto|\.env|iyzico|paytr|stripe/i;
 
 // Same bands as the cost table in docs/workflow/usage-limits.md §3 (1-2, 3-6, more files)
 export function flow({ files = 0, paths, installed = [], context, level: lvl }) {

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

@@ -10,7 +10,7 @@
 //   node .claude/hooks/freeze-guard.mjs --status         print state (lock and plan)
 // Scope shield (F-06): after /plan-task approval the plan's file list is saved; while a plan is active a write to an
 // EXISTING file not on the list is asked. New files are the structure guard's job; docs/, CHANGELOG.md are free. No plan: silent.
-// State: .claude/state/plan.json → { "task": "G-012", "paths": ["src/a.ts", "src/features/fatura/"] } (ending in /: folder)
+// State: .claude/state/plan.json → { "task": "G-012", "paths": ["src/a.ts", "src/features/invoice/"] } (ending in /: folder)
 //   node .claude/hooks/freeze-guard.mjs --plan-save <task> <path...>   save when no plan is active (asked: the user sees the list)
 //   node .claude/hooks/freeze-guard.mjs --plan-add <path...>           widen the list (with user approval)
 //   node .claude/hooks/freeze-guard.mjs --plan-end                     close when the task is done (asked)
@@ -134,7 +134,7 @@ function hook() {
   const paths = g.files.map(({ path: p }) => realPath(path.resolve(g.dir, p)));
   // Gate command approval record (gate.mjs, in the user folder ~/.vibe-kit/): the AI must not write it by hand
   const approval = paths.find((p) => /[\\/]\.vibe-kit([\\/]|$)/i.test(p));
-  if (approval) decide(g.tool, 'ask', /(preferences|tercihler)\.md$/i.test(approval)
+  if (approval) decide(g.tool, 'ask', /preferences[.]md$/i.test(approval)
     ? t(g.root, 'guard.freeze.prefsFile', { path: approval })
     : t(g.root, 'guard.freeze.gateApproval', { path: approval }));
   if (g.tool !== 'claude') {

package/.claude/hooks/gate.mjs

@@ -18,15 +18,12 @@ import { spawnSync } from 'node:child_process';
 import { changes } from './commit-gate.mjs';
 import { isCodeFile } from './edit-rounds.mjs';
 import { findRoot, isMain } from './shared.mjs';
-import { normalize } from './labels.mjs';
 import { specInvariants } from './dashboard-data.mjs';
 
-// Keys of the AGENTS.md → Commands block (Turkish keys of pre-3.48 projects are read through normalize)
+// Keys of the AGENTS.md → Commands block
 const CHECKS = ['lint', 'type check', 'test'];
 // The approval also covers the dev command and the preview address: preview.mjs runs the one and opens the other
 const APPROVED = [...CHECKS, 'dev', 'preview'];
-// The digest keeps the pre-3.48 names, so an approval given before the English labels stays valid
-const DIGEST_NAME = { 'type check': 'tip kontrol', dev: 'geliştirme', preview: 'önizleme' };
 const TIMEOUT = 10 * 60 * 1000;
 const BUFFER = 64 * 1024 * 1024;
 // A red check shows its last 30 lines; a longer output is kept whole in a file, read only when the tail is not enough
@@ -42,13 +39,21 @@ function failed(root, name, r) {
 
 // Only the "## Commands" section is read: a "test:" line elsewhere must not count as a command
 export function readCommands(md, names = CHECKS) {
-  const section = normalize(md).match(/^## Commands[^\n]*\n([\s\S]*?)(?=^## |(?![\s\S]))/m)?.[1] ?? '';
+  const section = md.match(/^## Commands[^\n]*\n([\s\S]*?)(?=^## |(?![\s\S]))/m)?.[1] ?? '';
   return names.map((name) => {
     const value = section.match(new RegExp(`^${name}:[ \\t]*(.*?)[ \\t\\r]*$`, 'm'))?.[1];
     return { name, command: value && !/^\[.*\]$/.test(value) ? value : null };
   });
 }
 
+// Keys under "## Commands" the kit does not know (a label written in another language): named, not silently ignored
+const KNOWN_KEYS = ['dev', 'preview', 'test', 'lint', 'type check', 'build'];
+export function unknownCommandKeys(md) {
+  const section = md.match(/^## Commands[^\n]*\n([\s\S]*?)(?=^## |(?![\s\S]))/m)?.[1] ?? '';
+  const fenced = [...section.matchAll(/^```[^\n]*\n([\s\S]*?)^```/gm)].map((m) => m[1]).join('\n'); // prose around the block is not a key
+  return [...fenced.matchAll(/^([\p{L}][\p{L}\p{N} _-]*?)[ \t]*:(?!\/\/)/gmu)].map((m) => m[1]).filter((k) => !KNOWN_KEYS.includes(k));
+}
+
 // The approval record lives outside the project, in the user folder (keyed by a digest of the project's real path): no repo,
 // archive or .git can carry an approval. The home folder comes from the OS (os.userInfo); HOME/USERPROFILE cannot redirect it.
 export function approvalPath(root) {
@@ -57,7 +62,7 @@ export function approvalPath(root) {
   const key = crypto.createHash('sha256').update(realRoot.toLowerCase()).digest('hex').slice(0, 32);
   return path.join(os.userInfo().homedir, '.vibe-kit', 'gate-approval', `${key}.json`);
 }
-const digest = (list) => crypto.createHash('sha256').update(JSON.stringify(list.map((k) => [DIGEST_NAME[k.name] ?? k.name, k.command]))).digest('hex');
+const digest = (list) => crypto.createHash('sha256').update(JSON.stringify(list.map((k) => [k.name, k.command]))).digest('hex');
 export const commandList = (list) => list.filter((k) => k.command).map((k) => `- ${k.name}: ${k.command}`).join('\n');
 export const readAgents = (root) => { try { return fs.readFileSync(path.join(root, 'AGENTS.md'), 'utf8'); } catch { return ''; } };
 export const approvedCommands = (root) => readCommands(readAgents(root), APPROVED);
@@ -113,7 +118,7 @@ function semgrep(root, files) {
 //   boundary after it; any slash style, JSON-escaped too; case-insensitive only on Windows).
 //   Note only: a generic C:\Users\<name>, /home/<name>/, /Users/<name>/ (a container path like /home/node/app or a route
 //   is not a machine path, so it never blocks).
-// "kit:yol-izinli" on the line or the line above allows a deliberate one (Dockerfile and JSON take no inline comment).
+// "kit:path-allowed" on the line or the line above allows a deliberate one (Dockerfile and JSON take no inline comment).
 // Only added lines of tracked files are read (an old path elsewhere in the file is not this change's); a new file is
 // read whole. Paths are read from the git top level, so a project in a monorepo subfolder is checked too.
 const ESCAPE = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -146,18 +151,19 @@ export function absPathCheck(root, files) {
     } catch { continue; }
     lines.forEach((l, i) => {
       if (added.has(f) && !added.get(f).has(i + 1)) return;
-      if (l.includes('kit:yol-izinli') || lines[i - 1]?.includes('kit:yol-izinli')) return;
+      if (l.includes('kit:path-allowed') || lines[i - 1]?.includes('kit:path-allowed')) return;
       const at = `${f}:${i + 1}: ${l.trim().slice(0, 120)}`;
       if (mine?.test(l)) red.push(at); else if (generic.test(l)) notes.push(at);
     });
   }
   const list = (a) => [...a.slice(0, 15), a.length > 15 ? `… and ${a.length - 15} more lines` : ''].filter(Boolean).join('\n');
-  if (red.length) return { name, status: 'failed', note: 'path specific to this machine; use import.meta.url, __dirname, path.join(root, …), os.tmpdir(). If deliberate, write kit:yol-izinli on the line or the line above',
+  if (red.length) return { name, status: 'failed', note: 'path specific to this machine; use import.meta.url, __dirname, path.join(root, …), os.tmpdir(). If deliberate, write kit:path-allowed on the line or the line above',
     output: list(red) };
   return { name, status: 'passed', ...(notes.length && { note: `${notes.length} lines have a path that looks like a user folder; fix it if it is machine-specific (does not block)`, output: list(notes) }) };
 }
 
-export const approvalNeeded = (list) => `command approval needed\nAGENTS.md → Commands is new or changed; these commands do not run unapproved:\n${commandList(list)}\n` +
+export const approvalNeeded = (list, unknown = []) => `command approval needed\nAGENTS.md → Commands is new or changed; these commands do not run unapproved:\n${commandList(list)}\n` +
+  (unknown.length ? `Keys the gate does not read (they never run; use dev, preview, test, lint, type check, build): ${unknown.join(', ')}\n` : '') +
   'Show the commands to the user and ask. If they approve: node .claude/hooks/gate.mjs --approve, then run the command again.';
 
 // Spec drift (F-23): a "must not change" behavior whose test is missing or red stops the gate; no result is only a note
@@ -185,9 +191,9 @@ export function runGate(root) {
   let signature = null, files = [];
   try { ({ signature, files } = changes()); } catch { /* not a git repo: the commands still run */ }
   const list = approvedCommands(root);
-  if (!isApproved(root, list)) return { passed: false, text: `## Gate · ${approvalNeeded(list)}` };
+  if (!isApproved(root, list)) return { passed: false, text: `## Gate · ${approvalNeeded(list, unknownCommandKeys(readAgents(root)))}` };
   const checks = [...list.filter((k) => CHECKS.includes(k.name)).map((k) => check(root, k)), semgrep(root, files)];
-  const empty = !checks.some((k) => k.status === 'passed');
+  const empty = !checks.some((k) => CHECKS.includes(k.name) && k.status === 'passed'); // Semgrep alone does not fill a gate
   const spec = specCheck(root, start); // after the test command, which may have refreshed the JUnit report; it does not fill an empty gate
   if (spec) checks.push(spec);
   checks.push(absPathCheck(root, files)); // after "empty": it does not fill a gate with no lint/test either
@@ -198,7 +204,9 @@ export function runGate(root) {
   const result = checks.some((k) => k.status === 'failed') ? 'Result: RED. The commit gate stays closed: fix it and run the gate again.'
     : empty ? 'Result: EMPTY, no check ran. Fill in AGENTS.md → Commands; the commit gate stays closed (if the user wants, commit-gate.mjs --skip).'
     : 'Result: GREEN.';
-  return { passed, text: [`## Gate · ${files.length} files changed`, ...checks.map(line), result].join('\n') };
+  const unknown = unknownCommandKeys(readAgents(root));
+  const warning = unknown.length ? [`⚠ AGENTS.md → Commands has keys the gate does not read: ${unknown.join(', ')}. Use dev, preview, test, lint, type check, build.`] : [];
+  return { passed, text: [`## Gate · ${files.length} files changed`, ...checks.map(line), ...warning, result].join('\n') };
 }
 
 if (isMain(import.meta.url)) {

package/.claude/hooks/labels.mjs

@@ -1,174 +1,114 @@
-// Label dictionary (3.48.0): the labels hooks read from project files, Turkish (pre-3.48 projects) and English.
-// Readers call normalize() first and then only know the English labels. Turkish reading goes away in 4.0.
+// Labels and values hooks read from project files. They stay English in every project language.
 
 export const LABELS = {
-  lastUpdated: { en: 'Last updated', tr: 'Son güncelleme' },
-  activePhase: { en: 'Active phase', tr: 'Aktif faz' },
-  activeTask: { en: 'Active task', tr: 'Aktif görev' },
-  setupStep: { en: 'Setup step', tr: 'Başlangıç adımı' },
-  questionMode: { en: 'Question mode', tr: 'Soru modu' },
-  profile: { en: 'Profile', tr: 'Profil' },
-  currentState: { en: 'Current state', tr: 'Şu anki durum' },
-  doneLastSession: { en: 'Done last session', tr: 'Son oturumda yapılanlar' },
-  nextStep: { en: 'Next step', tr: 'Sıradaki adım' },
-  pendingDecisions: { en: 'Pending decisions', tr: 'Bekleyen kararlar' },
-  whereWeLeftOff: { en: 'Where we left off', tr: 'Kaldığı yer' },
-  openIssues: { en: 'Open issues / blockers', tr: 'Açık sorunlar / bloklayıcılar' },
-  status: { en: 'Status', tr: 'Durum' },
-  commitReview: { en: 'Commit review', tr: 'Commit denetimi' },
-  members: { en: 'Members', tr: 'Üyeler' },
-  meetingLog: { en: 'Meeting log', tr: 'Toplantı günlüğü' },
-  decisionLog: { en: 'Decision log', tr: 'Karar günlüğü' },
-  phase: { en: 'Phase', tr: 'Faz' },
-  commands: { en: 'Commands', tr: 'Komutlar' },
-  dev: { en: 'dev', tr: 'geliştirme' },
-  preview: { en: 'preview', tr: 'önizleme' },
-  typeCheck: { en: 'type check', tr: 'tip kontrol' },
-  type: { en: 'Type', tr: 'Tür' },
-  class: { en: 'Class', tr: 'Sınıf' },
-  mustNotChange: { en: 'Behavior that must not change', tr: 'Değişmemesi gereken davranış' },
-  priority: { en: 'Priority', tr: 'Öncelik' },
-  outOfScope: { en: 'Out of scope', tr: 'Kapsam dışı' },
-  chosenTech: { en: 'Chosen technologies', tr: 'Seçilen teknolojiler' },
-  maintenanceLog: { en: 'Maintenance log', tr: 'Bakım kaydı' },
-  flags: { en: 'Flags', tr: 'Bayraklar' },
-  records: { en: 'Records', tr: 'Kayıtlar' },
-  unreleased: { en: 'Unreleased', tr: 'Yayınlanmamış' },
-  currency: { en: 'Currency', tr: 'Para birimi' },
-  price: { en: 'Price (per user, monthly)', tr: 'Fiyat (kullanıcı başı aylık)' },
-  paymentFee: { en: 'Payment fee (%)', tr: 'Ödeme komisyonu (%)' },
-  fixedCost: { en: 'Fixed monthly cost', tr: 'Sabit aylık maliyet' },
-  variableCost: { en: 'Variable cost per user (monthly)', tr: 'Kullanıcı başı değişken maliyet (aylık)' },
-  targetUsers: { en: 'Target active users', tr: 'Hedef aktif kullanıcı' },
-  freeShare: { en: 'Free user share (%)', tr: 'Ücretsiz kullanıcı oranı (%)' },
-  accounts: { en: 'Accounts', tr: 'Hesaplar' },
-  inbox: { en: 'Inbox', tr: 'Gelen kutusu' },
-  themes: { en: 'Themes', tr: 'Temalar' },
-  reports: { en: 'Reports', tr: 'Raporlar' },
-  alarms: { en: 'Alarms', tr: 'Alarmlar' },
-  chosenDirection: { en: 'Chosen direction', tr: 'Seçilen yön' },
-  valueProposition: { en: 'Value proposition', tr: 'Değer önerisi' },
-  criticalFlows: { en: 'Critical flows', tr: 'Kritik akışlar' },
-  learnedRules: { en: 'Learned rules', tr: 'Öğrenilen kurallar' },
-  rule: { en: 'Rule', tr: 'Kural' },
-  environments: { en: 'Environments (dev / prod)', tr: 'Ortamlar (dev / prod)' },
+  lastUpdated: 'Last updated',
+  activePhase: 'Active phase',
+  activeTask: 'Active task',
+  setupStep: 'Setup step',
+  questionMode: 'Question mode',
+  profile: 'Profile',
+  currentState: 'Current state',
+  doneLastSession: 'Done last session',
+  nextStep: 'Next step',
+  pendingDecisions: 'Pending decisions',
+  whereWeLeftOff: 'Where we left off',
+  openIssues: 'Open issues / blockers',
+  status: 'Status',
+  commitReview: 'Commit review',
+  members: 'Members',
+  meetingLog: 'Meeting log',
+  decisionLog: 'Decision log',
+  phase: 'Phase',
+  commands: 'Commands',
+  dev: 'dev',
+  preview: 'preview',
+  typeCheck: 'type check',
+  type: 'Type',
+  class: 'Class',
+  mustNotChange: 'Behavior that must not change',
+  priority: 'Priority',
+  outOfScope: 'Out of scope',
+  chosenTech: 'Chosen technologies',
+  maintenanceLog: 'Maintenance log',
+  flags: 'Flags',
+  records: 'Records',
+  unreleased: 'Unreleased',
+  currency: 'Currency',
+  price: 'Price (per user, monthly)',
+  paymentFee: 'Payment fee (%)',
+  fixedCost: 'Fixed monthly cost',
+  variableCost: 'Variable cost per user (monthly)',
+  targetUsers: 'Target active users',
+  freeShare: 'Free user share (%)',
+  accounts: 'Accounts',
+  inbox: 'Inbox',
+  themes: 'Themes',
+  reports: 'Reports',
+  alarms: 'Alarms',
+  chosenDirection: 'Chosen direction',
+  valueProposition: 'Value proposition',
+  criticalFlows: 'Critical flows',
+  learnedRules: 'Learned rules',
+  rule: 'Rule',
+  environments: 'Environments (dev / prod)',
 };
 
-// Values hooks read at known label or column positions. Readers compare with isValue(); never normalized in place.
+// Values hooks read at known label or column positions. Readers compare with isValue().
 export const VALUES = {
-  on: { en: 'on', tr: 'açık' },
-  off: { en: 'off', tr: 'kapalı' },
-  none: { en: 'none', tr: 'yok' },
-  setup: { en: 'Setup', tr: 'Başlangıç' },
-  notSetUp: { en: 'not set up', tr: 'kurulmadı' },
-  setUp: { en: 'set up', tr: 'kuruldu' },
-  full: { en: 'Full', tr: 'Tam' },
-  light: { en: 'Light', tr: 'Hafif' },
-  standard: { en: 'Standard', tr: 'Standart' },
-  waiting: { en: 'waiting', tr: 'bekliyor' },
-  automatic: { en: 'automatic', tr: 'otomatik' },
-  user: { en: 'user', tr: 'kullanıcı' },
-  oneWay: { en: 'one-way', tr: 'tek' },
-  twoWay: { en: 'two-way', tr: 'çift' },
-  yes: { en: 'yes', tr: 'evet' },
-  no: { en: 'no', tr: 'hayır' },
-  right: { en: 'right', tr: 'doğru' },
-  wrong: { en: 'wrong', tr: 'yanlış' },
-  passed: { en: 'passed', tr: 'geçti' },
-  failed: { en: 'failed', tr: 'kaldı' },
-  notRun: { en: 'not run', tr: 'koşulmadı' },
-  bug: { en: 'bug', tr: 'hata' },
-  feature: { en: 'feature', tr: 'özellik' },
-  request: { en: 'request', tr: 'istek' },
-  complaint: { en: 'complaint', tr: 'şikayet' },
-  praise: { en: 'praise', tr: 'övgü' },
-  question: { en: 'question', tr: 'soru' },
-  new: { en: 'new', tr: 'yeni' },
-  planned: { en: 'planned', tr: 'planlandı' },
-  done: { en: 'done', tr: 'yapıldı' },
-  rejected: { en: 'rejected', tr: 'reddedildi' },
-  merged: { en: 'merged', tr: 'birleşti' },
+  on: 'on',
+  off: 'off',
+  none: 'none',
+  setup: 'Setup',
+  notSetUp: 'not set up',
+  setUp: 'set up',
+  full: 'Full',
+  light: 'Light',
+  standard: 'Standard',
+  waiting: 'waiting',
+  automatic: 'automatic',
+  user: 'user',
+  oneWay: 'one-way',
+  twoWay: 'two-way',
+  yes: 'yes',
+  no: 'no',
+  right: 'right',
+  wrong: 'wrong',
+  passed: 'passed',
+  failed: 'failed',
+  notRun: 'not run',
+  bug: 'bug',
+  feature: 'feature',
+  request: 'request',
+  complaint: 'complaint',
+  praise: 'praise',
+  question: 'question',
+  new: 'new',
+  planned: 'planned',
+  done: 'done',
+  rejected: 'rejected',
+  merged: 'merged',
 };
 
-// The value in either language, case-insensitive (Turkish-aware), whole or followed by a non-letter:
-// "açık · kapalı konular: yok" is on, "açıklama" is not.
+// The value, case-insensitive, whole or followed by a non-letter: "on · closed topics: none" is on, "online" is not.
 export function isValue(text, key) {
   if (!Object.hasOwn(VALUES, key)) throw new Error(`unknown value: ${key}`);
   if (typeof text !== 'string') return false;
-  // Turkish lowercase for "AÇIK", plain lowercase for "FAILED" (Turkish would give "faıled")
-  const lower = (x) => [x.toLocaleLowerCase('tr'), x.toLowerCase()];
-  const texts = lower(text.trim());
-  return Object.values(VALUES[key]).flatMap(lower).some((w) =>
-    texts.some((s) => s.startsWith(w) && !/^[\p{L}\p{N}]/u.test(s.slice(w.length))));
+  const s = text.trim().toLowerCase();
+  const w = VALUES[key].toLowerCase();
+  return s.startsWith(w) && !/^[\p{L}\p{N}]/u.test(s.slice(w.length));
 }
 
 export function label(key) {
   if (!Object.hasOwn(LABELS, key)) throw new Error(`unknown label: ${key}`);
-  return LABELS[key].en;
+  return LABELS[key];
 }
 
-const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const COMMAND_KEYS = ['dev', 'preview', 'typeCheck'];
-// Longest first so a shorter label never wins over a longer one that starts the same way.
-const PAIRS = Object.entries(LABELS).filter(([k]) => !COMMAND_KEYS.includes(k)).map(([, v]) => v)
-  .sort((a, b) => b.tr.length - a.tr.length);
-const BOLD = PAIRS.map(({ tr, en }) => [new RegExp(`^\\*\\*${esc(tr)}:\\*\\*`), `**${en}:**`]);
-// The label must end at a non-letter: "## Faz 1" changes, "## Fazla mesai" does not. A PRD heading may be numbered
-// ("## 6. Kapsam dışı"), the CHANGELOG one is bracketed ("## [Yayınlanmamış]").
-const HEADING = [
-  [new RegExp(`^## \\[${esc(LABELS.unreleased.tr)}\\]`), `## [${LABELS.unreleased.en}]`],
-  ...PAIRS.map(({ tr, en }) => [new RegExp(`^## (\\d+\\. )?${esc(tr)}(?![\\p{L}\\p{N}])`, 'u'), `## $1${en}`]),
-];
-const COMMAND = COMMAND_KEYS.map((k) => [new RegExp(`^${esc(LABELS[k].tr)}:`), `${LABELS[k].en}:`]);
-const FENCE = /^ {0,3}(`{3,}|~{3,})/;
-const COMMANDS_HEADING = /^## (Komutlar|Commands)(?![\p{L}\p{N}])/u;
+const VERDICTS = [['CONDITIONAL', 'conditional'], ['APPROVE', 'approve'], ['REJECT', 'reject']];
 
-const swap = (line, rules) => {
-  for (const [re, to] of rules) if (re.test(line)) return line.replace(re, to);
-  return line;
-};
-
-// Rewrites Turkish labels to English only at label positions: a line-start **Label:**, a "## Label" heading,
-// and the keys of the AGENTS.md Commands block. Prose, tables, other code blocks and values stay byte-identical.
-export function normalize(text) {
-  const bom = text.startsWith('') ? '' : '';
-  const parts = text.slice(bom.length).split(/(\r?\n)/);
-  let fence = false;
-  let commands = false;
-  for (let i = 0; i < parts.length; i += 2) {
-    const line = parts[i];
-    if (FENCE.test(line)) { fence = !fence; continue; }
-    if (!fence && /^#{1,2} /.test(line)) commands = COMMANDS_HEADING.test(line);
-    if (commands) parts[i] = swap(line, [...COMMAND, ...HEADING]);
-    else if (!fence) parts[i] = swap(line, [...BOLD, ...HEADING]);
-  }
-  return bom + parts.join('');
-}
-
-// The label a writer uses for key in this file: the language the file already has for it (English if both, or neither).
-// Same positions as normalize: a line-start **Label:** or a "## Label" heading outside code blocks.
-export function labelIn(text, key) {
-  const { en, tr } = LABELS[key] ?? {};
-  if (!Object.hasOwn(LABELS, key)) throw new Error(`unknown label: ${key}`);
-  const at = (word) => new RegExp(`^(\\*\\*${esc(word)}:\\*\\*|## (\\d+\\. )?\\[?${esc(word)}(?![\\p{L}\\p{N}]))`, 'u');
-  const [isEn, isTr] = [at(en), at(tr)];
-  let fence = false, found = en;
-  for (const line of text.replace(/^/, '').split(/\r?\n/)) {
-    if (FENCE.test(line)) { fence = !fence; continue; }
-    if (fence) continue;
-    if (isEn.test(line)) return en;
-    if (isTr.test(line)) found = tr;
-  }
-  return found;
-}
-
-const VERDICTS = [['KOŞULLU ONAY', 'conditional'], ['CONDITIONAL', 'conditional'], ['KOŞULLU', 'conditional'],
-  ['APPROVE', 'approve'], ['ONAY', 'approve'], ['REJECT', 'reject'], ['RET', 'reject']];
-
-// Board result in either language. Fail-closed: anything that is not one clean verdict is 'unknown'.
+// Board result. Fail-closed: anything that is not one clean verdict is 'unknown'.
 export function verdict(text) {
   if (typeof text !== 'string') return 'unknown';
-  // "**Result:** RET", "**RET**"; after the word only the end, a dash, a bracket or ": , ; ." ("RET: güvenlik")
+  // "**Result:** REJECT", "**REJECT**"; after the word only the end, a dash, a bracket or ": , ; ." ("REJECT: security")
   const s = text.trim().replace(/^\*\*[^*]+:\*\*\s*/, '').replace(/^\*\*([^*]+)\*\*/, '$1').toUpperCase();
   for (const [word, result] of VERDICTS) {
     if (s.startsWith(word) && /^(?:\s*(?:$|[—–(-])|[:,;.])/.test(s.slice(word.length))) return result;