create-devoplus-one-app 0.0.0-stage → 0.1.0-next.158

package/templates/hedef-takibi/files/src/app.ts.tpl

@@ -0,0 +1,740 @@
+// {{nameTr}} — hedef ve aksiyon takibi. Uçlar (hepsi oturum ister; kimlik platformdan gelir):
+//   GET    /api/periods[?…] · /api/periods/{id}              dönemler (herkes) — hazır liste + Excel
+//   POST   /api/periods · PATCH/DELETE /api/periods/{id}      dönem tanımı (hedef yöneticisi); DURUM bu uçlardan yazılmaz
+//   POST   /api/periods/{id}/close · /reopen                  dönemi kapat / yeniden aç (hedef yöneticisi)
+//   GET    /api/goals[?…]                                    Hedeflerim: sorumlusu BEN olan hedefler (süzgeç sunucuda zorlanır)
+//   POST   /api/goals · GET/PATCH/DELETE /api/goals/{id}      hedef (sorumlu, sorumlunun yöneticisi ya da hedef yöneticisi)
+//   GET/POST /api/goals/{id}/key-results                      ölçülebilir sonuçlar
+//   PATCH/DELETE /api/key-results/{id}                       ölçülebilir sonucun tanımı (güncel değer bu uçtan YAZILMAZ)
+//   POST   /api/key-results/{id}/check-ins                    { value, note? } — güncel değer + geçmiş satırı TEK toplu yazım
+//   GET    /api/goals/{id}/check-ins                         değer güncelleme geçmişi
+//   GET/POST /api/goals/{id}/actions · PATCH/DELETE /api/actions/{id}   aksiyonlar
+//   GET    /api/team/goals[?period_id=…]                      Ekip panosu: doğrudan bana bağlı çalışanların hedefleri (+ Excel)
+//   GET    /api/board[?period_id=…] · /api/board/goals[?…]    Dönem panosu: ekip başına ağırlıklı ilerleme + hedef listesi (+ Excel)
+// ⛔ İlerleme YALNIZ sunucuda hesaplanır (`progress.ts`); istemcinin gönderdiği `progress` ya da `current_value` 400 alır.
+// ⛔ Görünürlük sunucuda organizasyon şemasından türetilir: kişi kendi hedeflerini, yönetici doğrudan bağlılarının
+//    hedeflerini, hedef yöneticisi ({{permissionPrefix}}Manage) hepsini görür. Görülemeyen hedef 404'tür (var olduğu sızmaz).
+// ⛔ Kapanmış dönemin hedefleri, ölçülebilir sonuçları ve aksiyonları değiştirilemez (409).
+import {
+  OneError,
+  createCrudHandler,
+  exportResponse,
+  getMyOrgContext,
+  getOrgSchema,
+  getOrgUsersWithManagers,
+  hasPermission,
+  isActingSession,
+  logAudit,
+  logError,
+  requirePermission,
+  requireUser,
+  toCsv,
+  toXlsx,
+  type ExportColumn,
+  type OneContext,
+  type OneUser,
+  type OrgUserWithManagers,
+} from '@devoplus/one-sdk'
+import manifest from '../one.manifest.json' with { type: 'json' }
+import { agentTools } from './agent.ts'
+import { dataModel } from './data/types.ts'
+import { fieldError, forward, matchId, nowIso, onlyFields, personValue, readJsonObject, withQuery } from './lib/http.ts'
+import { and, applied, changedOne, insertWhen, recordWrite, removeWhen, sql, updateWhen, withUniqueCheck, type Sql } from './lib/record.ts'
+import { createApp, json, type AppDefinition, type BaseEnv, type RouteInput } from './lib/server.ts'
+import { directReports, keyResultProgress, parseValue } from './progress.ts'
+import { findPeriod, periodSummary } from './queries.ts'
+import { renderShell, renderShellScript } from './shell.ts'
+
+export type Env = BaseEnv
+
+export const APP_NAME = { tr: {{nameTrJs}}, en: {{nameEnJs}} }
+/** Hedef yöneticisi izni (manifest `permissions`): dönem tanımlar ve kapatır, bütün hedefleri görür ve düzenler. */
+export const MANAGE_PERMISSION = '{{permissionPrefix}}Manage'
+
+export const periods = createCrudHandler({ model: dataModel, entity: 'periods', records: 'shared', canWrite: MANAGE_PERMISSION })
+// ⛔ Aşağıdaki kayıt uçları DOĞRUDAN yönlendirilmez: görünürlük denetimi `routes` içinde yapılıp istek onlara iletilir.
+// Alt kayıtlar `/internal` önekindedir; o önek dışarıdan hiçbir uca bağlanmaz (404).
+export const goals = createCrudHandler({ model: dataModel, entity: 'goals', records: 'shared' })
+const INTERNAL = '/internal'
+export const keyResults = createCrudHandler({ model: dataModel, entity: 'key_results', records: 'shared', basePath: INTERNAL })
+export const checkIns = createCrudHandler({ model: dataModel, entity: 'check_ins', records: 'shared', basePath: INTERNAL })
+export const actions = createCrudHandler({ model: dataModel, entity: 'actions', records: 'shared', basePath: INTERNAL })
+
+const PERIOD_FIELDS = ['code', 'name', 'start_date', 'end_date']
+const GOAL_FIELDS = ['period_id', 'title', 'description', 'owner', 'weight']
+const KEY_RESULT_FIELDS = ['name', 'unit', 'start_value', 'target_value']
+const ACTION_FIELDS = ['description', 'owner', 'due_date', 'done']
+const NOTE_MAX = 200
+/** Kişi ve ekip adlarının veri modelindeki sınırı (`owner_name`, `team_name`, `actor_name`). */
+const NAME_MAX = 120
+const SINGLE_LINE_BAD = /[\u0000-\u001f\u007f]/
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/
+const LIST_MAX = 200
+const EXPORT_MAX = 10_000
+
+/** Hedefin bağlı olduğu dönem AÇIK mı (toplu yazımların koşulu; `goals` tablosu `g` adıyla). */
+const OPEN_PERIOD_SQL = `EXISTS (SELECT 1 FROM "periods" p WHERE p.id = g.period_id AND p.status = 'open' AND p.deleted_at IS NULL)`
+/**
+ * Hedefin ilerlemesini ölçülebilir sonuçlarından yeniden hesaplar: ortalama, bir ondalık (`progress.ts` → `goalProgress`
+ * ile aynı kural). Bağlar: hedef kimliği (iki kez), zaman, kişi. Dönem kapalıysa hiçbir şey yazmaz.
+ */
+const GOAL_PROGRESS_SQL =
+  'UPDATE "goals" AS g SET progress = coalesce((SELECT ROUND(AVG(k.progress), 1) FROM "key_results" k WHERE k.goal_id = ? AND k.deleted_at IS NULL), 0), ' +
+  `updated_at = ?, updated_by = ? WHERE g.id = ? AND g.deleted_at IS NULL AND ${OPEN_PERIOD_SQL}`
+
+const LOCKED = () => new OneError(409, 'APP-E-030', 'Dönem kapandı; bu dönemin hedefleri yalnız görüntülenebilir.')
+const NOT_FOUND = () => new OneError(404, 'APP-E-404', 'Hedef bulunamadı.')
+const CHANGED = () => new OneError(409, 'APP-E-031', 'Kayıt bu arada değişti; sayfayı yenileyip yeniden deneyin.')
+
+// ── Kim kimi görür ───────────────────────────────────────────────────────────────────────────────────────────────
+
+interface Viewer {
+  user: OneUser
+  /** Oturumdaki kişinin org kimliği (küçük harf); portalda kişi kaydı yoksa `null`. */
+  orgId: string | null
+  name: string | null
+  manage: boolean
+  users(): Promise<OrgUserWithManagers[]>
+  reports(): Promise<Set<string>>
+}
+
+async function viewer(input: RouteInput<Env>): Promise<Viewer> {
+  const user = requireUser(input.ctx)
+  const api = input.api()
+  const me = await getMyOrgContext(api)
+  const orgId = me ? me.orgUserId.toLowerCase() : null
+  let list: Promise<OrgUserWithManagers[]> | null = null
+  const users = () => (list ??= getOrgUsersWithManagers(api))
+  return {
+    user,
+    orgId,
+    name: me?.fullName ?? null,
+    manage: hasPermission(input.ctx, MANAGE_PERMISSION),
+    users,
+    reports: async () => (orgId ? directReports(await users(), orgId) : new Set<string>()),
+  }
+}
+
+async function canSee(v: Viewer, ownerOrgId: string): Promise<boolean> {
+  const owner = ownerOrgId.toLowerCase()
+  return v.manage || owner === v.orgId || (await v.reports()).has(owner)
+}
+
+/**
+ * Bir hedefe (ve alt kayıtlarına) YAZIM koşulu — `goals` satırı `g` adıyla: hedef silinmemiş, dönemi açık ve sorumlusu
+ * yazanın görebildiği biri (hedef yöneticisi için koşul yok). ⛔ Okumadaki `goalAccess` denetiminin yazım ifadesindeki
+ * karşılığıdır: denetimden sonra hedef silinir, dönem kapanır ya da hedef başkasına verilirse yazım olmaz.
+ */
+async function goalWritable(v: Viewer): Promise<Sql> {
+  const owners = await visibleOwners(v, true)
+  return and(
+    sql('g.deleted_at IS NULL'),
+    sql(OPEN_PERIOD_SQL),
+    owners === null ? sql('') : sql('g.owner_org_id IN (SELECT value FROM json_each(?))', JSON.stringify(owners)),
+  )
+}
+
+/** `EXISTS (hedef yazılabilir)` — `goalRef` hedef kimliğidir: bağlı değer (`?`) ya da yazılan satırın kolonu. */
+async function goalGate(v: Viewer, goalRef: Sql, extra: Sql = sql('')): Promise<Sql> {
+  const w = and(await goalWritable(v), extra)
+  return sql(`EXISTS (SELECT 1 FROM "goals" g WHERE g.id = ${goalRef.sql} AND ${w.sql})`, ...goalRef.params, ...w.params)
+}
+
+/** Yazma kapısı (savunma derinliği): Vekalet / Yerine Görüntüle oturumunda platform yazmayı zaten durdurur. */
+function requireWriter(ctx: OneContext): OneUser {
+  const user = requireUser(ctx)
+  if (isActingSession(ctx)) throw new OneError(403, 'APP-E-403', 'Vekalet ya da Yerine Görüntüle oturumunda bu uygulamada kayıt değiştirilemez; yalnız görüntüleyebilirsiniz.')
+  return user
+}
+
+interface GoalRow {
+  id: string
+  period_id: string
+  owner_org_id: string
+  owner_name: string | null
+  title: string
+  period_status: string | null
+}
+
+async function findGoal(env: Env, id: string): Promise<GoalRow | null> {
+  return env.DB.prepare(
+    'SELECT g.id, g.period_id, g.owner_org_id, g.owner_name, g.title, p.status AS period_status FROM "goals" g ' +
+      'LEFT JOIN "periods" p ON p.id = g.period_id AND p.deleted_at IS NULL WHERE g.id = ? AND g.deleted_at IS NULL',
+  )
+    .bind(id)
+    .first<GoalRow>()
+}
+
+/** Hedefe erişim: görülemeyen hedef 404; yazmada dönem açık olmalı (409). */
+async function goalAccess(input: RouteInput<Env>, id: string, mode: 'read' | 'write'): Promise<{ goal: GoalRow; v: Viewer }> {
+  if (mode === 'write') requireWriter(input.ctx)
+  const goal = await findGoal(input.env, id)
+  if (!goal) throw NOT_FOUND()
+  const v = await viewer(input)
+  if (!(await canSee(v, goal.owner_org_id))) throw NOT_FOUND()
+  if (mode === 'write' && goal.period_status !== 'open') throw LOCKED()
+  return { goal, v }
+}
+
+/** Sorumlunun adı ve ekibi (departmanı) organizasyon şemasından; şema okunamazsa ekip adı boş kalır. */
+async function ownerDetails(input: RouteInput<Env>, v: Viewer, ownerOrgId: string, fallbackName: string) {
+  const person = (await v.users()).find((u) => u.id.toLowerCase() === ownerOrgId)
+  if (!person) throw fieldError('owner', 'Kişi organizasyon şemasında bulunamadı.')
+  let teamName: string | null = null
+  if (person.departmentId) {
+    try {
+      const schema = await getOrgSchema(input.api())
+      teamName = schema.departments.find((d) => d.id === person.departmentId)?.departmentName?.trim() || null
+    } catch (error) {
+      logError(input.ctx, 'departman adı okunamadı', error)
+    }
+  }
+  return {
+    owner_name: clip(person.fullName || fallbackName, NAME_MAX),
+    team_id: person.departmentId ? person.departmentId.toLowerCase() : null,
+    team_name: clip(teamName, NAME_MAX),
+  }
+}
+
+/** Organizasyon şemasından gelen adı veri modelinin sınırına kırpar (boş ad `null`). */
+function clip(value: string | null | undefined, max: number): string | null {
+  const text = value?.trim() ?? ''
+  return text === '' ? null : [...text].slice(0, max).join('')
+}
+
+function textValue(raw: unknown, field: string, max: number, required: boolean): string | null {
+  if (raw === undefined || raw === null || (typeof raw === 'string' && raw.trim() === '')) {
+    if (required) throw fieldError(field, 'Bu alan zorunlu.')
+    return null
+  }
+  if (typeof raw !== 'string' || SINGLE_LINE_BAD.test(raw) || [...raw.trim()].length > max) throw fieldError(field, `En çok ${max} karakterlik tek satır olmalı.`)
+  return raw.trim()
+}
+
+function numberValue(raw: unknown, field: string): number {
+  const check = parseValue(raw)
+  if (!check.ok) throw fieldError(field, check.message)
+  return check.value
+}
+
+// ── Dönemler ────────────────────────────────────────────────────────────────────────────────────────────────────
+
+function checkDates(start: unknown, end: unknown): void {
+  if (typeof start === 'string' && typeof end === 'string' && DATE_RE.test(start) && DATE_RE.test(end) && start > end)
+    throw fieldError('end_date', 'Bitiş tarihi başlangıçtan önce olamaz.')
+}
+
+async function periodWrite(input: RouteInput<Env>, id: string | null): Promise<Response> {
+  const { request, env, ctx, method } = input
+  const user = requireWriter(ctx)
+  requirePermission(ctx, MANAGE_PERMISSION)
+  if (id && method === 'DELETE') {
+    // ⛔ "Dönemde hedef yok" koşulu silmeyle AYNI ifadededir; hedef ekleme de dönemin açık ve silinmemiş olmasını kendi
+    // ifadesinde ister (karşılıklı kapı). Önce sayıp sonra silmek, arada eklenen hedefi silinmiş bir döneme bağlı bırakırdı.
+    const now = nowIso()
+    const res = await env.DB.prepare(
+      'UPDATE "periods" SET deleted_at = ?, updated_at = ?, updated_by = ? WHERE id = ? AND deleted_at IS NULL AND NOT EXISTS (SELECT 1 FROM "goals" WHERE period_id = ? AND deleted_at IS NULL)',
+    )
+      .bind(now, now, user.sub, id, id)
+      .run()
+    if (Number(res.meta.changes ?? 0) !== 1) {
+      if (!(await findPeriod(env, { id }))) throw new OneError(404, 'APP-E-404', 'Dönem bulunamadı.')
+      throw new OneError(409, 'APP-E-032', 'Bu dönemde hedef var; dönem silinemez. Dönemi kapatabilirsiniz.')
+    }
+    logAudit(ctx, 'period.delete', id)
+    return new Response(null, { status: 204 })
+  }
+  const body = onlyFields(await readJsonObject(request), PERIOD_FIELDS)
+  if (id) {
+    checkDates(body.start_date, body.end_date)
+    const write = recordWrite(dataModel, 'periods', body, 'update')
+    const start = typeof body.start_date === 'string' ? body.start_date : null
+    const end = typeof body.end_date === 'string' ? body.end_date : null
+    const now = nowIso()
+    // ⛔ "Başlangıç bitişten sonra olamaz" kuralı yazımla AYNI ifadededir ve YAZIMDAN SONRAKİ satıra uygulanır: gönderilmeyen
+    // tarih satırın o anki değeridir. Önce okuyup sonra yazmak, iki ayrı düzenlemenin (biri başlangıcı, öteki bitişi
+    // değiştiren) ikisinin de ayrı ayrı geçip kuralı birlikte bozmasına izin verirdi.
+    // Hedefler dönem kodunun KOPYASINI taşır (liste ve Excel onu gösterir): kod değişince kopyalar aynı toplu yazımda
+    // güncellenir. Hedef ekleme de kodu kendi ifadesinde dönemin o anki koduyla karşılaştırır (bayat kod yazılmaz).
+    const [updated] = await withUniqueCheck(dataModel, 'periods', () =>
+      env.DB.batch([
+        updateWhen(env.DB, write, { id, actor: user.sub, now, when: sql('coalesce(?, "start_date") <= coalesce(?, "end_date")', start, end) }),
+        ...(body.code !== undefined
+          ? [env.DB.prepare('UPDATE "goals" SET period_code = (SELECT code FROM "periods" WHERE id = ?) WHERE period_id = ? AND deleted_at IS NULL').bind(id, id)]
+          : []),
+      ]),
+    )
+    if (!changedOne(updated)) {
+      const current = await findPeriod(env, { id })
+      if (!current) throw new OneError(404, 'APP-E-404', 'Dönem bulunamadı.')
+      if ((start ?? current.start_date) > (end ?? current.end_date)) throw fieldError('end_date', 'Bitiş tarihi başlangıçtan önce olamaz.')
+      throw CHANGED()
+    }
+    return recordResponse(input, periods, id, 200)
+  }
+  checkDates(body.start_date, body.end_date)
+  return (await periods.handle(forward(request, periods.path, 'POST', { ...body, status: 'open' }), env.DB, ctx))!
+}
+
+async function periodStatus(input: RouteInput<Env>, id: string, to: 'open' | 'closed'): Promise<Response> {
+  const { env, ctx } = input
+  const user = requireWriter(ctx)
+  requirePermission(ctx, MANAGE_PERMISSION)
+  const now = nowIso()
+  const res = await env.DB.prepare('UPDATE "periods" SET status = ?, closed_at = ?, updated_at = ?, updated_by = ? WHERE id = ? AND status <> ? AND deleted_at IS NULL')
+    .bind(to, to === 'closed' ? now : null, now, user.sub, id, to)
+    .run()
+  if (Number(res.meta.changes ?? 0) !== 1) {
+    if (!(await findPeriod(env, { id }))) throw new OneError(404, 'APP-E-404', 'Dönem bulunamadı.')
+    throw new OneError(409, 'APP-E-033', to === 'closed' ? 'Dönem zaten kapalı.' : 'Dönem zaten açık.')
+  }
+  logAudit(ctx, to === 'closed' ? 'period.close' : 'period.reopen', id)
+  return json(await findPeriod(env, { id }))
+}
+
+// ── Hedefler ────────────────────────────────────────────────────────────────────────────────────────────────────
+
+async function myGoals(input: RouteInput<Env>): Promise<Response> {
+  const v = await viewer(input)
+  if (!v.orgId) throw new OneError(409, 'APP-E-010', 'Portalda kişi kaydınız bulunamadı; hedefleriniz gösterilemiyor. Portal yöneticinize başvurun.')
+  // Süzgeç sunucuda ZORLANIR: istemcinin gönderdiği sorumlu değeri yok sayılır.
+  return (await goals.handle(withQuery(input.request, input.url.pathname, (p) => p.set('owner_org_id', v.orgId!)), input.env.DB, input.ctx))!
+}
+
+async function readGoal(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { goal, v } = await goalAccess(input, id, 'read')
+  const res = (await goals.handle(input.request, input.env.DB, input.ctx))!
+  if (!res.ok) return res
+  const record = (await res.json()) as Record<string, unknown>
+  return json({ ...record, period_status: goal.period_status, editable: goal.period_status === 'open' && !isActingSession(input.ctx) && (await canSee(v, goal.owner_org_id)) })
+}
+
+/** Kaydı hazır kayıt ucunun gösterimiyle döndürür (yazımı uç kendisi yaptığında). */
+async function recordResponse(input: RouteInput<Env>, handler: typeof goals, id: string, status: 200 | 201): Promise<Response> {
+  const res = (await handler.handle(forward(input.request, `${handler.path}/${id}`, 'GET'), input.env.DB, input.ctx))!
+  if (!res.ok || status === 200) return res
+  const out = json(await res.json(), 201)
+  out.headers.set('location', `${handler.path}/${id}`)
+  return out
+}
+
+async function createGoal(input: RouteInput<Env>): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requireWriter(ctx)
+  const body = onlyFields(await readJsonObject(request), GOAL_FIELDS)
+  const v = await viewer(input)
+  if (typeof body.period_id !== 'string' || body.period_id === '') throw fieldError('period_id', 'Dönem seçin.')
+  const period = await findPeriod(env, { id: body.period_id })
+  if (!period) throw fieldError('period_id', 'Dönem bulunamadı.')
+  if (period.status !== 'open') throw LOCKED()
+  const picked = personValue(body.owner, 'owner')
+  const ownerId = picked?.id ?? v.orgId
+  if (!ownerId) throw fieldError('owner', 'Hedefin sorumlusunu seçin.')
+  if (!(await canSee(v, ownerId)))
+    throw new OneError(403, 'APP-E-403', 'Yalnız kendinize ya da doğrudan size bağlı çalışanlara hedef verebilirsiniz.')
+  const details = await ownerDetails(input, v, ownerId, picked?.name ?? v.name ?? '')
+  const { owner: _owner, ...rest } = body
+  const write = recordWrite(dataModel, 'goals', { ...rest, period_id: period.id, period_code: period.code, owner_org_id: ownerId, ...details, progress: 0 }, 'create')
+  const id = crypto.randomUUID()
+  const now = nowIso()
+  // ⛔ Hedef yalnız dönem HÂLÂ açık, silinmemiş ve kodu okuduğumuz kodsa eklenir (aynı ifadede): okuma ile ekleme arasında
+  // dönem kapanır, silinir ya da kodu değişirse hedef yazılmaz (bayat kod kopyası kalmaz). Dönem silme de "dönemde hedef
+  // yok" koşulunu kendi ifadesinde ister.
+  const when = sql(`EXISTS (SELECT 1 FROM "periods" p WHERE p.id = ? AND p.status = 'open' AND p.deleted_at IS NULL AND p.code = ?)`, period.id, period.code)
+  if (!(await applied(write, insertWhen(env.DB, write, { id, actor: user.sub, now, when })))) {
+    const latest = await findPeriod(env, { id: period.id })
+    if (!latest) throw fieldError('period_id', 'Dönem bulunamadı.')
+    throw latest.status !== 'open' ? LOCKED() : CHANGED()
+  }
+  logAudit(ctx, 'goal.create', id)
+  return recordResponse(input, goals, id, 201)
+}
+
+/**
+ * Koşullu yazım hiçbir satırı değiştirmediyse nedeni: hedef yok ya da artık görülemiyor (404), dönem kapalı (409) ya da
+ * kayıt bu arada değişti (409).
+ */
+async function goalWriteRefused(env: Env, v: Viewer, id: string): Promise<OneError> {
+  const goal = await findGoal(env, id)
+  if (!goal || !(await canSee(v, goal.owner_org_id))) return NOT_FOUND()
+  return goal.period_status !== 'open' ? LOCKED() : CHANGED()
+}
+
+async function writeGoal(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx, method } = input
+  const user = requireWriter(ctx)
+  const { v } = await goalAccess(input, id, 'write')
+  const now = nowIso()
+  // ⛔ Erişim denetiminin (hedef var, dönem açık, sorumlusu görülebilir) karşılığı yazımla AYNI ifadededir: denetimden
+  // sonra dönem kapanır, hedef silinir ya da başkasına verilirse yazım olmaz.
+  const when = await goalWritable(v)
+  if (method === 'DELETE') {
+    if (!changedOne(await removeWhen(env.DB, 'goals', { id, actor: user.sub, now, when, alias: 'g' }).run())) throw await goalWriteRefused(env, v, id)
+    logAudit(ctx, 'goal.delete', id)
+    return new Response(null, { status: 204 })
+  }
+  const body = onlyFields(await readJsonObject(request), GOAL_FIELDS.filter((f) => f !== 'period_id'))
+  const { owner, ...record } = body as Record<string, unknown>
+  if ('owner' in body) {
+    const picked = personValue(owner, 'owner')
+    if (!picked) throw fieldError('owner', 'Hedefin sorumlusunu seçin.')
+    if (!(await canSee(v, picked.id))) throw new OneError(403, 'APP-E-403', 'Hedefi yalnız kendinize ya da doğrudan size bağlı bir çalışana verebilirsiniz.')
+    Object.assign(record, { owner_org_id: picked.id }, await ownerDetails(input, v, picked.id, picked.name))
+  }
+  const write = recordWrite(dataModel, 'goals', record, 'update')
+  if (!(await applied(write, updateWhen(env.DB, write, { id, actor: user.sub, now, when, alias: 'g' })))) throw await goalWriteRefused(env, v, id)
+  return recordResponse(input, goals, id, 200)
+}
+
+// ── Ölçülebilir sonuçlar ve değer güncellemesi ─────────────────────────────────────────────────────────────────
+
+interface KeyResultRow {
+  id: string
+  goal_id: string
+  name: string
+  unit: string | null
+  start_value: number
+  target_value: number
+  current_value: number
+}
+
+async function findKeyResult(env: Env, id: string): Promise<KeyResultRow | null> {
+  return env.DB.prepare('SELECT id, goal_id, name, unit, start_value, target_value, current_value FROM "key_results" WHERE id = ? AND deleted_at IS NULL')
+    .bind(id)
+    .first<KeyResultRow>()
+}
+
+async function readKeyResult(env: Env, id: string) {
+  return env.DB.prepare('SELECT id, goal_id, name, unit, start_value, target_value, current_value, progress, updated_at FROM "key_results" WHERE id = ?')
+    .bind(id)
+    .first<Record<string, unknown>>()
+}
+
+/**
+ * Hedefin ilerlemesini yeniden hesaplayan ifade; yalnız `marker` tutuyorsa (yani aynı toplu yazımdaki asıl yazım
+ * gerçekten olduysa) yazar. Asıl yazımın koşulu tutmadıysa hedefin damgası (`updated_by`) da değişmez.
+ */
+function goalProgress(env: Env, goalId: string, now: string, actor: string, marker: Sql) {
+  return env.DB.prepare(`${GOAL_PROGRESS_SQL} AND ${marker.sql}`).bind(goalId, now, actor, goalId, ...marker.params)
+}
+
+/** Ölçülebilir sonuca koşullu yazım tutmadıysa nedeni: sonuç yok (404) ya da hedefin nedeni. */
+async function keyResultWriteRefused(env: Env, v: Viewer, id: string, goalId: string): Promise<OneError> {
+  if (!(await findKeyResult(env, id))) return new OneError(404, 'APP-E-404', 'Ölçülebilir sonuç bulunamadı.')
+  return goalWriteRefused(env, v, goalId)
+}
+
+async function createKeyResult(input: RouteInput<Env>, goalId: string): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requireWriter(ctx)
+  const { v } = await goalAccess(input, goalId, 'write')
+  const body = onlyFields(await readJsonObject(request), KEY_RESULT_FIELDS)
+  const name = textValue(body.name, 'name', 160, true)!
+  const unit = textValue(body.unit, 'unit', 20, false)
+  const start = body.start_value === undefined ? 0 : numberValue(body.start_value, 'start_value')
+  if (body.target_value === undefined) throw fieldError('target_value', 'Hedef değeri girin.')
+  const target = numberValue(body.target_value, 'target_value')
+  const write = recordWrite(
+    dataModel,
+    'key_results',
+    { goal_id: goalId, name, unit, start_value: start, target_value: target, current_value: start, progress: keyResultProgress(start, target, start) },
+    'create',
+  )
+  const id = crypto.randomUUID()
+  const now = nowIso()
+  // ⛔ Ölçülebilir sonuç ve hedefin yeni ilerlemesi TEK toplu yazım; ekleme hedefin erişim koşulunu (silinmemiş, dönemi
+  // açık, sorumlusu görülebilir) kendi ifadesinde ister ve ilerleme yalnız ekleme olduysa yeniden hesaplanır.
+  const [inserted] = await env.DB.batch([
+    insertWhen(env.DB, write, { id, actor: user.sub, now, when: await goalGate(v, sql('?', goalId)) }),
+    goalProgress(env, goalId, now, user.sub, sql('EXISTS (SELECT 1 FROM "key_results" WHERE id = ? AND deleted_at IS NULL)', id)),
+  ])
+  if (!changedOne(inserted)) throw await goalWriteRefused(env, v, goalId)
+  logAudit(ctx, 'key-result.create', id)
+  return json(await readKeyResult(env, id), 201)
+}
+
+async function writeKeyResult(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx, method } = input
+  const user = requireWriter(ctx)
+  const kr = await findKeyResult(env, id)
+  if (!kr) throw new OneError(404, 'APP-E-404', 'Ölçülebilir sonuç bulunamadı.')
+  const { v } = await goalAccess(input, kr.goal_id, 'write')
+  const now = nowIso()
+  // ⛔ Hedefin erişim koşulu (silinmemiş, dönemi açık, sorumlusu görülebilir) yazımla AYNI ifadededir.
+  const gate = await goalGate(v, sql('"key_results".goal_id'))
+  // Damga (`updated_at` + `updated_by`) bu yazımın gerçekten olduğunun işaretidir: ilerleme yalnız o zaman yeniden hesaplanır.
+  const stamped = (column: 'updated_at' | 'deleted_at') => sql(`EXISTS (SELECT 1 FROM "key_results" WHERE id = ? AND "${column}" = ? AND updated_by = ?)`, id, now, user.sub)
+  if (method === 'DELETE') {
+    const [removed] = await env.DB.batch([removeWhen(env.DB, 'key_results', { id, actor: user.sub, now, when: gate }), goalProgress(env, kr.goal_id, now, user.sub, stamped('deleted_at'))])
+    if (!changedOne(removed)) throw await keyResultWriteRefused(env, v, id, kr.goal_id)
+    return new Response(null, { status: 204 })
+  }
+  // Güncel değer ve ilerleme bu uçtan YAZILMAZ (`onlyFields` 400 döner): değer yalnız değer güncellemesiyle değişir.
+  const body = onlyFields(await readJsonObject(request), KEY_RESULT_FIELDS)
+  if (Object.keys(body).length === 0) throw fieldError('', 'Güncellenecek alan gönderilmedi.')
+  // Yalnız GÖNDERİLEN alanlar yazılır (ad ve birim okunmuş değerle ezilmez); metin alanlarının arama kolonu da güncellenir.
+  const record: Record<string, unknown> = {}
+  if ('name' in body) record.name = textValue(body.name, 'name', 160, true)
+  if ('unit' in body) record.unit = textValue(body.unit, 'unit', 20, false)
+  if ('start_value' in body) record.start_value = numberValue(body.start_value, 'start_value')
+  if ('target_value' in body) record.target_value = numberValue(body.target_value, 'target_value')
+  const start = (record.start_value as number | undefined) ?? kr.start_value
+  const target = (record.target_value as number | undefined) ?? kr.target_value
+  const write = recordWrite(dataModel, 'key_results', record, 'update')
+  // İlerleme okunan başlangıç/hedef/güncel değerden hesaplanır: üçü okuduğumuz hâlde değilse (eşzamanlı değişiklik) yazılmaz.
+  const when = and(sql('start_value = ? AND target_value = ? AND current_value = ?', kr.start_value, kr.target_value, kr.current_value), gate)
+  const [updated] = await env.DB.batch([
+    updateWhen(env.DB, write, { id, actor: user.sub, now, when, also: sql('"progress" = ?', keyResultProgress(start, target, kr.current_value)) }),
+    goalProgress(env, kr.goal_id, now, user.sub, stamped('updated_at')),
+  ])
+  if (!changedOne(updated)) throw await keyResultWriteRefused(env, v, id, kr.goal_id)
+  return json(await readKeyResult(env, id))
+}
+
+async function checkIn(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requireWriter(ctx)
+  const kr = await findKeyResult(env, id)
+  if (!kr) throw new OneError(404, 'APP-E-404', 'Ölçülebilir sonuç bulunamadı.')
+  const { v } = await goalAccess(input, kr.goal_id, 'write')
+  const body = onlyFields(await readJsonObject(request), ['value', 'note'])
+  if (body.value === undefined) throw fieldError('value', 'Yeni değeri girin.')
+  const value = numberValue(body.value, 'value')
+  const note = textValue(body.note, 'note', NOTE_MAX, false)
+  const progress = keyResultProgress(kr.start_value, kr.target_value, value)
+  const checkInId = crypto.randomUUID()
+  const now = nowIso()
+  const write = recordWrite(dataModel, 'check_ins', { key_result_id: id, goal_id: kr.goal_id, old_value: kr.current_value, new_value: value, note, actor_name: clip(v.name, NAME_MAX) }, 'create')
+  // ⛔ Geçmiş satırı, güncel değer ve hedefin ilerlemesi TEK toplu yazımdır (ikisi birlikte ya da hiçbiri):
+  //   1. Geçmiş satırı yalnız değer HÂLÂ okuduğumuz değerse ve hedef yazılabilirse (silinmemiş, dönemi açık, sorumlusu
+  //      görülebilir) eklenir: eşzamanlı iki güncelleme birbirinin önceki değerini ezmez; ikincisi 409 alır.
+  //   2. Değer ve ilerleme yalnız BU geçmiş satırı eklendiyse değişir. 3. Hedefin ilerlemesi yeniden hesaplanır.
+  const krCurrent = sql(
+    'EXISTS (SELECT 1 FROM "key_results" k WHERE k.id = ? AND k.deleted_at IS NULL AND k.current_value = ? AND k.start_value = ? AND k.target_value = ?)',
+    id,
+    kr.current_value,
+    kr.start_value,
+    kr.target_value,
+  )
+  const marker = sql('EXISTS (SELECT 1 FROM "check_ins" WHERE id = ?)', checkInId)
+  const [inserted, changed] = await env.DB.batch([
+    insertWhen(env.DB, write, { id: checkInId, actor: user.sub, now, when: and(krCurrent, await goalGate(v, sql('?', kr.goal_id))) }),
+    env.DB.prepare(`UPDATE "key_results" SET current_value = ?, progress = ?, updated_at = ?, updated_by = ? WHERE id = ? AND ${marker.sql}`).bind(value, progress, now, user.sub, id, ...marker.params),
+    goalProgress(env, kr.goal_id, now, user.sub, marker),
+  ])
+  if (!changedOne(inserted) || !changedOne(changed)) throw await keyResultWriteRefused(env, v, id, kr.goal_id)
+  logAudit(ctx, 'key-result.check-in', id, { from: kr.current_value, to: value })
+  const goal = await env.DB.prepare('SELECT progress FROM "goals" WHERE id = ?').bind(kr.goal_id).first<{ progress: number }>()
+  return json({ id: checkInId, keyResult: await readKeyResult(env, id), goal: { id: kr.goal_id, progress: goal?.progress ?? 0 } }, 201)
+}
+
+// ── Aksiyonlar ──────────────────────────────────────────────────────────────────────────────────────────────────
+
+function actionRecord(body: Record<string, unknown>): Record<string, unknown> {
+  const { owner, done, ...rest } = body
+  const record: Record<string, unknown> = { ...rest }
+  if ('owner' in body) {
+    const person = personValue(owner, 'owner')
+    record.owner_org_id = person?.id ?? null
+    record.owner_name = person?.name || null
+  }
+  if ('done' in body) {
+    if (typeof done !== 'boolean') throw fieldError('done', 'Tamamlandı alanı evet ya da hayır olmalı.')
+    record.done = done
+  }
+  return record
+}
+
+async function createAction(input: RouteInput<Env>, goalId: string): Promise<Response> {
+  const { request, env, ctx } = input
+  const user = requireWriter(ctx)
+  const { goal, v } = await goalAccess(input, goalId, 'write')
+  const body = onlyFields(await readJsonObject(request), ACTION_FIELDS.filter((f) => f !== 'done'))
+  const record = actionRecord(body)
+  // Sorumlu verilmezse hedefin sorumlusu aksiyona KOPYALANIR: kopyalanan değer okunduğu hâlde değilse (hedef bu arada
+  // başkasına verildiyse) ekleme olmaz, eski sorumlu yazılmaz.
+  const inherited = !('owner' in body)
+  if (inherited) Object.assign(record, { owner_org_id: goal.owner_org_id, owner_name: goal.owner_name })
+  const write = recordWrite(dataModel, 'actions', { ...record, goal_id: goalId, done: false }, 'create')
+  const id = crypto.randomUUID()
+  const now = nowIso()
+  // ⛔ Aksiyon yalnız hedef HÂLÂ yazılabilirse (silinmemiş, dönemi açık, sorumlusu görülebilir) eklenir (aynı ifadede).
+  const when = await goalGate(v, sql('?', goalId), inherited ? sql('g.owner_org_id = ?', goal.owner_org_id) : sql(''))
+  if (!(await applied(write, insertWhen(env.DB, write, { id, actor: user.sub, now, when })))) throw await goalWriteRefused(env, v, goalId)
+  return recordResponse(input, actions, id, 201)
+}
+
+async function writeAction(input: RouteInput<Env>, id: string): Promise<Response> {
+  const { request, env, ctx, method } = input
+  const user = requireWriter(ctx)
+  const row = await env.DB.prepare('SELECT goal_id FROM "actions" WHERE id = ? AND deleted_at IS NULL').bind(id).first<{ goal_id: string }>()
+  if (!row) throw new OneError(404, 'APP-E-404', 'Aksiyon bulunamadı.')
+  const { v } = await goalAccess(input, row.goal_id, 'write')
+  const now = nowIso()
+  // ⛔ Hedefin erişim koşulu (silinmemiş, dönemi açık, sorumlusu görülebilir) yazımla AYNI ifadededir.
+  const when = await goalGate(v, sql('"actions".goal_id'))
+  const refused = async () => {
+    const still = await env.DB.prepare('SELECT 1 AS n FROM "actions" WHERE id = ? AND deleted_at IS NULL').bind(id).first()
+    return still ? goalWriteRefused(env, v, row.goal_id) : new OneError(404, 'APP-E-404', 'Aksiyon bulunamadı.')
+  }
+  if (method === 'DELETE') {
+    if (!changedOne(await removeWhen(env.DB, 'actions', { id, actor: user.sub, now, when }).run())) throw await refused()
+    return new Response(null, { status: 204 })
+  }
+  const record = actionRecord(onlyFields(await readJsonObject(request), ACTION_FIELDS))
+  const write = recordWrite(dataModel, 'actions', record, 'update')
+  // Tamamlanma zamanını sunucu yazar ve durum DEĞİŞMEDİYSE dokunmaz: karşılaştırma satırın yazımdan önceki değeriyle,
+  // aynı ifadede yapılır (okunmuş bir değere göre değil).
+  const done = 'done' in record ? (record.done ? 1 : 0) : null
+  const also = done === null ? undefined : sql('"done_at" = CASE WHEN "done" = ? THEN "done_at" WHEN ? = 1 THEN ? ELSE NULL END', done, done, now)
+  if (!(await applied(write, updateWhen(env.DB, write, { id, actor: user.sub, now, when, ...(also ? { also } : {}) })))) throw await refused()
+  return recordResponse(input, actions, id, 200)
+}
+
+/** Hedefin alt kayıtları (ölçülebilir sonuç · değer geçmişi · aksiyon): hedef görülebiliyorsa, hedefe süzülmüş liste. */
+async function childList(input: RouteInput<Env>, goalId: string, handler: typeof actions): Promise<Response> {
+  await goalAccess(input, goalId, 'read')
+  return (await handler.handle(withQuery(input.request, handler.path, (p) => p.set('goal_id', goalId)), input.env.DB, input.ctx))!
+}
+
+// ── Ekip panosu ve dönem panosu ─────────────────────────────────────────────────────────────────────────────────
+
+const GOAL_COLUMNS: ExportColumn[] = [
+  { key: 'period_code', title: { tr: 'Dönem', en: 'Period' } },
+  { key: 'team_name', title: { tr: 'Ekip', en: 'Team' } },
+  { key: 'owner_name', title: { tr: 'Sorumlu', en: 'Owner' } },
+  { key: 'title', title: { tr: 'Hedef', en: 'Goal' } },
+  { key: 'weight', title: { tr: 'Ağırlık', en: 'Weight' }, type: 'number' },
+  { key: 'progress', title: { tr: 'İlerleme (%)', en: 'Progress (%)' }, type: 'number' },
+  { key: 'updated_at', title: { tr: 'Son güncelleme', en: 'Last updated' }, type: 'datetime' },
+]
+const SORTABLE = new Set(['title', 'owner_name', 'team_name', 'weight', 'progress', 'updated_at'])
+
+/** Kimin hedefleri: hedef yöneticisi için `null` (hepsi); diğerleri için doğrudan bağlılar (+ istenirse kendisi). */
+async function visibleOwners(v: Viewer, includeSelf: boolean): Promise<string[] | null> {
+  if (v.manage) return null
+  const owners = [...(await v.reports())]
+  if (includeSelf && v.orgId) owners.push(v.orgId)
+  return owners
+}
+
+function intParam(params: URLSearchParams, name: string, min: number, max: number, fallback: number): number {
+  const raw = params.get(name)
+  if (raw === null) return fallback
+  const n = /^\d{1,6}$/.test(raw) ? Number(raw) : NaN
+  if (!Number.isInteger(n) || n < min || n > max) throw fieldError(name, `"${name}" ${min} ile ${max} arasında bir tamsayı olmalı.`)
+  return n
+}
+
+// Ekip ve dönem panosunun hedef listesi: hazır liste bileşeninin `page` / `limit` parametrelerini okur, `_page` /
+// `_size` okumaz. Bu yüzden sayfa betiğindeki loadAll'a BAĞLANMAZ (her istekte ilk sayfa döner).
+async function goalList(input: RouteInput<Env>, includeSelf: boolean): Promise<Response> {
+  const { env, url } = input
+  const v = await viewer(input)
+  const owners = await visibleOwners(v, includeSelf)
+  const p = url.searchParams
+  const format = p.get('format')
+  if (format !== null && format !== 'xlsx' && format !== 'csv') throw fieldError('format', '"format" xlsx ya da csv olmalı.')
+  const lang = p.get('lang') === 'en' || p.get('_lang') === 'en' ? 'en' : 'tr'
+  const sort = p.get('sort') ?? 'team_name'
+  if (!SORTABLE.has(sort)) throw fieldError('sort', `"${sort}" alanına göre sıralanamaz.`)
+  const order = p.get('order') === 'desc' ? 'DESC' : 'ASC'
+  const page = intParam(p, 'page', 1, 100_000, 1)
+  const size = format ? EXPORT_MAX : intParam(p, 'limit', 1, LIST_MAX, 50)
+  // Dönem verilmezse en son başlayan dönem (dönem panosunun grafiğiyle aynı varsayılan).
+  const periodId = p.get('period_id') || (await findPeriod(env, {}))?.id || null
+  const where = ['g.deleted_at IS NULL', 'g.period_id = ?']
+  const params: string[] = [periodId ?? '']
+  let items: Record<string, unknown>[] = []
+  let total = 0
+  if (periodId && (owners === null || owners.length > 0)) {
+    if (owners !== null) {
+      where.push('g.owner_org_id IN (SELECT value FROM json_each(?))')
+      params.push(JSON.stringify(owners))
+    }
+    const sql = where.join(' AND ')
+    const [count, list] = await env.DB.batch<Record<string, unknown>>([
+      env.DB.prepare(`SELECT COUNT(*) AS n FROM "goals" g WHERE ${sql}`).bind(...params),
+      env.DB.prepare(
+        'SELECT g.id, g.period_id, g.period_code, g.title, g.owner_org_id, g.owner_name, g.team_id, g.team_name, g.weight, g.progress, g.updated_at ' +
+          `FROM "goals" g WHERE ${sql} ORDER BY g."${sort}" ${order}, g.id ${order} LIMIT ? OFFSET ?`,
+      ).bind(...params, size, format ? 0 : (page - 1) * size),
+    ])
+    total = Number(count?.results[0]?.n ?? 0)
+    items = list?.results ?? []
+  }
+  if (format) {
+    if (total > EXPORT_MAX) throw new OneError(400, 'APP-E-400', `${total} hedef var; en çok ${EXPORT_MAX} hedef aktarılabilir. Süzgeci daraltın.`)
+    const fileName = `${lang === 'tr' ? 'Hedefler' : 'Goals'} ${new Date().toISOString().slice(0, 10)}`
+    if (format === 'csv') return exportResponse(toCsv(items, GOAL_COLUMNS, { lang }), { fileName, format })
+    return exportResponse(toXlsx(items, GOAL_COLUMNS, { lang, sheetName: lang === 'tr' ? 'Hedefler' : 'Goals' }), { fileName, format: 'xlsx' })
+  }
+  return json({ items, page, pageSize: size, total, nextCursor: page * size < total ? String(page + 1) : null })
+}
+
+async function board(input: RouteInput<Env>): Promise<Response> {
+  const v = await viewer(input)
+  const period = await findPeriod(input.env, { id: input.url.searchParams.get('period_id') })
+  if (!period) return json({ period: null, overall: 0, goalCount: 0, teams: [] })
+  const owners = await visibleOwners(v, true)
+  return json({ period, ...(await periodSummary(input.env, period.id, owners)) })
+}
+
+async function routes(input: RouteInput<Env>): Promise<Response | null> {
+  const { url, method, env, ctx, request } = input
+  const path = url.pathname
+  const read = method === 'GET' || method === 'HEAD'
+
+  // Dönemler
+  const periodClose = matchId(path, periods.path, 'close')
+  if (periodClose && method === 'POST') return periodStatus(input, periodClose, 'closed')
+  const periodReopen = matchId(path, periods.path, 'reopen')
+  if (periodReopen && method === 'POST') return periodStatus(input, periodReopen, 'open')
+  if (path === periods.path && method === 'POST') return periodWrite(input, null)
+  const periodId = matchId(path, periods.path)
+  if (periodId && (method === 'PATCH' || method === 'DELETE')) return periodWrite(input, periodId)
+  if ((path === periods.path || path.startsWith(`${periods.path}/`)) && read) return periods.handle(request, env.DB, ctx)
+
+  // Panolar
+  if (path === '/api/team/goals' && read) return goalList(input, false)
+  if (path === '/api/board/goals' && read) return goalList(input, true)
+  if (path === '/api/board' && read) return board(input)
+
+  // Hedefin alt kayıtları
+  for (const [segment, handler] of [['key-results', keyResults], ['check-ins', checkIns], ['actions', actions]] as const) {
+    const goalId = matchId(path, goals.path, segment)
+    if (!goalId) continue
+    if (read) return childList(input, goalId, handler)
+    if (method === 'POST' && segment === 'key-results') return createKeyResult(input, goalId)
+    if (method === 'POST' && segment === 'actions') return createAction(input, goalId)
+    throw new OneError(405, 'APP-E-405', 'Bu adreste bu yöntem kullanılamaz.')
+  }
+  const krCheckIn = matchId(path, '/api/key-results', 'check-ins')
+  if (krCheckIn && method === 'POST') return checkIn(input, krCheckIn)
+  const krId = matchId(path, '/api/key-results')
+  if (krId && (method === 'PATCH' || method === 'DELETE')) return writeKeyResult(input, krId)
+  const actionId = matchId(path, '/api/actions')
+  if (actionId && (method === 'PATCH' || method === 'DELETE')) return writeAction(input, actionId)
+
+  // Hedefler
+  if (path === goals.path && method === 'POST') return createGoal(input)
+  const goalId = matchId(path, goals.path)
+  if (goalId && read) return readGoal(input, goalId)
+  if (goalId && (method === 'PATCH' || method === 'DELETE')) return writeGoal(input, goalId)
+  if (goalId && method === 'PUT') throw new OneError(405, 'APP-E-405', 'Hedef PATCH ile güncellenir.')
+  // Liste, Excel ve yazdırma: yalnız sorumlusu BEN olan hedefler.
+  if ((path === goals.path || path.startsWith(`${goals.path}/`)) && read) return myGoals(input)
+  return null
+}
+
+export const definition: Omit<AppDefinition<Env>, 'guide'> = {
+  manifest,
+  tools: agentTools,
+  page: renderShell,
+  script: renderShellScript,
+  routes,
+}
+
+export function buildApp(guide: string) {
+  return createApp<Env>({ ...definition, guide })
+}