throughline 0.6.3 → 0.8.0

package/src/haiku-summarizer.mjs

@@ -1,14 +1,20 @@
 /**
  * haiku-summarizer.mjs — L1 要約生成
  *
- * 基本方針:
- *   - Claude primary では、codex-sidecar diagnostics が configured なら Codex sidecar で
- *     L2→L1 要約する。
- *   - Claude primary では、codex-sidecar が disabled / unavailable なら現行の Claude
- *     Haiku 要約に戻す。
- *   - Claude primary では、どちらも失敗したら L2 全文を L1 に入れる（情報欠損ゼロ）。
+ * 基本方針 (モデル・比率の根拠は ADR 0015 の実測評価):
+ *   - Claude primary の backend 順序: codex-sidecar (configured 時)
+ *     → Codex CLI (既定 gpt-5.6-luna / effort low) → Claude Haiku
+ *     → L2 全文を L1 に入れる（情報欠損ゼロ）。各段の失敗理由は結果に記録する。
  *   - Codex primary では、Codex CLI backend を使い、失敗時は Haiku / raw L2 へ
  *     fallback せず explicit error にする。
+ *   - 要約の目標量は削減割合で決める（既定 1/5 = 0.2）。プロンプトへは割合から
+ *     換算した「約N文字」で渡す（LLM の長さ制御は割合指定より文字数指定が安定）。
+ *
+ * 設定 (env):
+ *   - THROUGHLINE_L1_MODEL:  Codex CLI 要約モデル (既定 'gpt-5.6-luna')
+ *   - THROUGHLINE_L1_EFFORT: Codex CLI reasoning effort (既定 'low')
+ *   - THROUGHLINE_L1_RATIO:  削減割合 (0 < r <= 1、既定 0.2 = 元の 1/5)。
+ *     不正値は黙って既定に落とさず explicit error にする。
  *
  * Claude Haiku 経路:
  *   Claude Max 契約前提。`claude -p --model claude-haiku-4-5-20251001`
@@ -47,6 +53,12 @@ import {
 import { spawnPortableSync } from './portable-spawn-sync.mjs';
 
 const MODEL = 'claude-haiku-4-5-20251001';
+// Codex CLI 要約の既定。gpt-5.6-luna@low@1/5 は 2026-07-17 の実測評価で選定
+// (8 実ソース × effort {none,low,medium} × 2 反復、要点拾い率 low=93% で
+//  medium と同点・none+4pt、レイテンシ median 12.4s。ADR 0015)。
+const L1_DEFAULT_CODEX_MODEL = 'gpt-5.6-luna';
+const L1_DEFAULT_CODEX_EFFORT = 'low';
+const L1_DEFAULT_RATIO = 0.2; // 元テキストの 1/5
 const MAX_RETRIES = 2;
 const TIMEOUT_MS = 30_000;
 const SIDECAR_TIMEOUT_MS = 10 * 60_000;
@@ -65,8 +77,33 @@ function ensureWorkdir() {
   }
 }
 
-function buildPrompt(l2Text) {
-  const targetChars = Math.max(20, Math.round(l2Text.length / 5));
+/**
+ * 削減割合を env から解決する。不正値は黙って既定へ落とさず explicit error
+ * （フォールバック禁止原則。設定ミスは沈黙劣化ではなく即座に見えるべき）。
+ */
+export function resolveL1Ratio(env = process.env) {
+  const raw = env.THROUGHLINE_L1_RATIO;
+  if (raw === undefined || raw === '') return L1_DEFAULT_RATIO;
+  const ratio = Number(raw);
+  if (!Number.isFinite(ratio) || ratio <= 0 || ratio > 1) {
+    throw new Error(
+      `invalid THROUGHLINE_L1_RATIO: ${JSON.stringify(raw)} ` +
+        '(expected a fraction in (0, 1], e.g. 0.2 = compress to 1/5)',
+    );
+  }
+  return ratio;
+}
+
+function resolveL1CodexModel(env) {
+  return env.THROUGHLINE_L1_MODEL || L1_DEFAULT_CODEX_MODEL;
+}
+
+function resolveL1CodexEffort(env) {
+  return env.THROUGHLINE_L1_EFFORT || L1_DEFAULT_CODEX_EFFORT;
+}
+
+function buildPrompt(l2Text, ratio) {
+  const targetChars = Math.max(20, Math.round(l2Text.length * ratio));
   return (
     `次の日本語テキストを約${targetChars}文字に要約してください。` +
     `固有名詞・数値・因果関係を優先して残し、枝葉は落としてください。` +
@@ -74,9 +111,9 @@ function buildPrompt(l2Text) {
   );
 }
 
-function buildCodexPrompt(l2Text) {
+function buildCodexPrompt(l2Text, ratio) {
   return (
-    `${buildPrompt(l2Text)}\n\n` +
+    `${buildPrompt(l2Text, ratio)}\n\n` +
     'Output contract:\n' +
     '- Return only the summary text.\n' +
     '- Do not include Markdown fences, JSON, labels, or commentary.\n\n' +
@@ -228,7 +265,7 @@ function summarizeWithHaiku(l2Text, prompt, env) {
   return { summary: l2Text, fromFallback: true, source: 'raw_l2' };
 }
 
-function summarizeWithCodexCli(l2Text, { projectPath, env }) {
+function summarizeWithCodexCli(l2Text, { projectPath, env, ratio }) {
   if (!projectPath) {
     const err = new Error('Codex CLI summarizer requires projectPath');
     err.source = 'codex-cli';
@@ -244,8 +281,11 @@ function summarizeWithCodexCli(l2Text, { projectPath, env }) {
   }
 
   const command = env.THROUGHLINE_CODEX_CLI_BIN ?? 'codex';
-  const prompt = buildCodexPrompt(l2Text);
+  const prompt = buildCodexPrompt(l2Text, ratio);
   const childEnv = { ...env, [CODEX_SUMMARIZER_GUARD_ENV]: '1' };
+  // モデル・effort は明示指定する。--ignore-user-config は isolation のために
+  // 必要だが、これにより ~/.codex/config.toml のモデル選択も読まれないため、
+  // 明示しないと CLI 内蔵デフォルトで走ってしまう (ADR 0015 で実測確認)。
   const result = spawnPortableSync(
     command,
     [
@@ -256,6 +296,10 @@ function summarizeWithCodexCli(l2Text, { projectPath, env }) {
       '--skip-git-repo-check',
       '--sandbox',
       'read-only',
+      '-m',
+      resolveL1CodexModel(env),
+      '-c',
+      `model_reasoning_effort=${resolveL1CodexEffort(env)}`,
       '-C',
       projectPath,
       prompt,
@@ -291,10 +335,27 @@ function summarizeWithCodexCli(l2Text, { projectPath, env }) {
 }
 
 /**
- * L2 本文を約 1/5 に要約する。
+ * claude-primary 用: Codex CLI 要約を試み、失敗は throw せず理由付きで返す。
+ * codex-primary の explicit error 契約 (summarizeWithCodexCli) はそのまま使い、
+ * ここでは「次の backend へ進む」ための宣言済み fallback として理由を保存する。
+ */
+function tryCodexCliSummary(l2Text, { projectPath, env, ratio }) {
+  try {
+    const result = summarizeWithCodexCli(l2Text, { projectPath, env, ratio });
+    return { summary: result.summary, reason: 'codex_cli_ok' };
+  } catch (err) {
+    return {
+      summary: null,
+      reason: err?.reason ? `codex_cli_${err.reason}` : 'codex_cli_failed',
+    };
+  }
+}
+
+/**
+ * L2 本文を削減割合 (既定 1/5、THROUGHLINE_L1_RATIO で変更可) で要約する。
  * @param {string} l2Text ターンの会話本文（user+assistant を適当な形式で結合した文字列）
  * @param {{ projectPath?: string, env?: NodeJS.ProcessEnv, hostMode?: 'claude-primary' | 'codex-primary' | 'unknown' }} [options]
- * @returns {{ summary: string, fromFallback: boolean, source?: string, sidecarReason?: string }}
+ * @returns {{ summary: string, fromFallback: boolean, source?: string, sidecarReason?: string, codexCliReason?: string }}
  */
 export function summarizeToL1(
   l2Text,
@@ -304,8 +365,10 @@ export function summarizeToL1(
     return { summary: '(no content)', fromFallback: true, source: 'empty' };
   }
 
+  const ratio = resolveL1Ratio(env);
+
   if (hostMode === 'codex-primary') {
-    return summarizeWithCodexCli(l2Text, { projectPath, env });
+    return summarizeWithCodexCli(l2Text, { projectPath, env, ratio });
   }
 
   if (hostMode !== 'claude-primary') {
@@ -320,7 +383,7 @@ export function summarizeToL1(
     return { summary: l2Text, fromFallback: true, source: 'recursion_guard' };
   }
 
-  const prompt = buildPrompt(l2Text);
+  const prompt = buildPrompt(l2Text, ratio);
   const sidecar = tryCodexSidecarSummary(l2Text, { projectPath, prompt, env });
   if (sidecar.summary) {
     return {
@@ -331,9 +394,23 @@ export function summarizeToL1(
     };
   }
 
+  // sidecar 不在時は Codex CLI (既定 gpt-5.6-luna@low)。Haiku より要点拾い率が
+  // 同等以上・レイテンシ半分以下・タイムアウト失敗なし (ADR 0015 実測)。
+  const codexCli = tryCodexCliSummary(l2Text, { projectPath, env, ratio });
+  if (codexCli.summary) {
+    return {
+      summary: codexCli.summary,
+      fromFallback: false,
+      source: 'codex-cli',
+      sidecarReason: sidecar.reason,
+      codexCliReason: codexCli.reason,
+    };
+  }
+
   const haiku = summarizeWithHaiku(l2Text, prompt, env);
   return {
     ...haiku,
     sidecarReason: sidecar.reason,
+    codexCliReason: codexCli.reason,
   };
 }

package/src/haiku-summarizer.test.mjs

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { delimiter, join } from 'node:path';
-import { summarizeToL1 } from './haiku-summarizer.mjs';
+import { summarizeToL1, resolveL1Ratio } from './haiku-summarizer.mjs';
 
 function makeBin(dir, name, body) {
   const script = join(dir, `${name}.mjs`);
@@ -117,7 +117,7 @@ test('summarizeToL1: accepts stable SidecarResult summary without status field',
   }
 });
 
-test('summarizeToL1: when sidecar is disabled, keeps current Haiku-compatible path', () => {
+test('summarizeToL1: sidecar disabled + codex CLI failing falls back to Haiku path', () => {
   const dir = mkdtempSync(join(tmpdir(), 'tl-l1-haiku-'));
   try {
     makeBin(
@@ -125,6 +125,13 @@ test('summarizeToL1: when sidecar is disabled, keeps current Haiku-compatible pa
       'claude',
       `for await (const _chunk of process.stdin) {}
 process.stdout.write('haiku summary\\n');
+`,
+    );
+    const codex = makeBin(
+      dir,
+      'codex',
+      `process.stderr.write('codex unavailable\\n');
+process.exit(9);
 `,
     );
 
@@ -134,6 +141,7 @@ process.stdout.write('haiku summary\\n');
       env: {
         ...envWithPrependedPath(dir),
         THROUGHLINE_CODEX_SIDECAR_DISABLED: '1',
+        THROUGHLINE_CODEX_CLI_BIN: codex,
       },
     });
 
@@ -141,12 +149,13 @@ process.stdout.write('haiku summary\\n');
     assert.equal(result.fromFallback, false);
     assert.equal(result.source, 'haiku');
     assert.equal(result.sidecarReason, 'sidecar_disabled');
+    assert.equal(result.codexCliReason, 'codex_cli_codex_cli_failed');
   } finally {
     rmSync(dir, { recursive: true, force: true });
   }
 });
 
-test('summarizeToL1: sidecar run failure keeps current Haiku-compatible path', () => {
+test('summarizeToL1: sidecar run failure falls to Codex CLI (gpt-5.6-luna@low) before Haiku', () => {
   const dir = mkdtempSync(join(tmpdir(), 'tl-l1-sidecar-fail-'));
   try {
     const sidecar = makeBin(
@@ -158,34 +167,130 @@ test('summarizeToL1: sidecar run failure keeps current Haiku-compatible path', (
   process.stderr.write('sidecar failed\\n');
   process.exit(42);
 }
+`,
+    );
+    const argsFile = join(dir, 'codex-args.txt');
+    const codex = makeBin(
+      dir,
+      'codex',
+      `import { writeFileSync } from 'node:fs';
+writeFileSync(${JSON.stringify(argsFile)}, process.argv.slice(2).join('\\n') + '\\n');
+for await (const _chunk of process.stdin) {}
+process.stdout.write('luna summary after sidecar failure\\n');
 `,
     );
     makeBin(
       dir,
       'claude',
       `for await (const _chunk of process.stdin) {}
-process.stdout.write('haiku after sidecar failure\\n');
+process.stdout.write('haiku should not run\\n');
 `,
     );
 
     const result = summarizeToL1('long enough turn text', {
       hostMode: 'claude-primary',
-      projectPath: '/repo',
+      projectPath: dir,
       env: {
         ...envWithPrependedPath(dir),
         THROUGHLINE_CODEX_SIDECAR_BIN: sidecar,
+        THROUGHLINE_CODEX_CLI_BIN: codex,
       },
     });
 
-    assert.equal(result.summary, 'haiku after sidecar failure');
+    assert.equal(result.summary, 'luna summary after sidecar failure');
     assert.equal(result.fromFallback, false);
-    assert.equal(result.source, 'haiku');
+    assert.equal(result.source, 'codex-cli');
     assert.equal(result.sidecarReason, 'sidecar_run_failed');
+    assert.equal(result.codexCliReason, 'codex_cli_ok');
+
+    const argv = readFileSync(argsFile, 'utf8').trim().split('\n');
+    const modelIdx = argv.indexOf('-m');
+    assert.ok(modelIdx >= 0, 'explicit -m must be passed');
+    assert.equal(argv[modelIdx + 1], 'gpt-5.6-luna');
+    assert.ok(argv.includes('model_reasoning_effort=low'), 'explicit effort must be passed');
   } finally {
     rmSync(dir, { recursive: true, force: true });
   }
 });
 
+test('summarizeToL1: THROUGHLINE_L1_MODEL / THROUGHLINE_L1_EFFORT override codex defaults', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-l1-model-override-'));
+  try {
+    const argsFile = join(dir, 'codex-args.txt');
+    const codex = makeBin(
+      dir,
+      'codex',
+      `import { writeFileSync } from 'node:fs';
+writeFileSync(${JSON.stringify(argsFile)}, process.argv.slice(2).join('\\n') + '\\n');
+for await (const _chunk of process.stdin) {}
+process.stdout.write('override summary\\n');
+`,
+    );
+
+    const result = summarizeToL1('long enough turn text', {
+      hostMode: 'codex-primary',
+      projectPath: dir,
+      env: {
+        ...process.env,
+        THROUGHLINE_CODEX_CLI_BIN: codex,
+        THROUGHLINE_L1_MODEL: 'gpt-5.6-terra',
+        THROUGHLINE_L1_EFFORT: 'medium',
+      },
+    });
+
+    assert.equal(result.summary, 'override summary');
+    const argv = readFileSync(argsFile, 'utf8').trim().split('\n');
+    assert.equal(argv[argv.indexOf('-m') + 1], 'gpt-5.6-terra');
+    assert.ok(argv.includes('model_reasoning_effort=medium'));
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('summarizeToL1: THROUGHLINE_L1_RATIO changes the target chars in the prompt', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'tl-l1-ratio-'));
+  try {
+    const argsFile = join(dir, 'codex-args.txt');
+    const codex = makeBin(
+      dir,
+      'codex',
+      `import { writeFileSync } from 'node:fs';
+writeFileSync(${JSON.stringify(argsFile)}, process.argv.slice(2).join('\\n') + '\\n');
+for await (const _chunk of process.stdin) {}
+process.stdout.write('ratio summary\\n');
+`,
+    );
+
+    const text = 'a'.repeat(1000);
+    summarizeToL1(text, {
+      hostMode: 'codex-primary',
+      projectPath: dir,
+      env: {
+        ...process.env,
+        THROUGHLINE_CODEX_CLI_BIN: codex,
+        THROUGHLINE_L1_RATIO: '0.1',
+      },
+    });
+
+    const argsText = readFileSync(argsFile, 'utf8');
+    assert.match(argsText, /約100文字に要約/, 'ratio 0.1 of 1000 chars = 100 target chars');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('resolveL1Ratio: default 0.2, and invalid values are explicit errors (no silent default)', () => {
+  assert.equal(resolveL1Ratio({}), 0.2);
+  assert.equal(resolveL1Ratio({ THROUGHLINE_L1_RATIO: '0.1' }), 0.1);
+  for (const bad of ['abc', '0', '-0.2', '1.5', 'NaN']) {
+    assert.throws(
+      () => resolveL1Ratio({ THROUGHLINE_L1_RATIO: bad }),
+      /invalid THROUGHLINE_L1_RATIO/,
+      `must reject ${bad}`,
+    );
+  }
+});
+
 test('summarizeToL1: unknown host mode is an explicit error', () => {
   assert.throws(
     () =>
@@ -228,7 +333,7 @@ process.stdout.write('codex summary\\n');
     assert.equal(result.source, 'codex-cli');
     const argsText = readFileSync(argsFile, 'utf8').trim();
     const argv = argsText.split('\n');
-    assert.deepEqual(argv.slice(0, 8), [
+    assert.deepEqual(argv.slice(0, 12), [
       'exec',
       '--ephemeral',
       '--ignore-user-config',
@@ -236,9 +341,13 @@ process.stdout.write('codex summary\\n');
       '--skip-git-repo-check',
       '--sandbox',
       'read-only',
+      '-m',
+      'gpt-5.6-luna',
+      '-c',
+      'model_reasoning_effort=low',
       '-C',
     ]);
-    assert.equal(argv[8], dir);
+    assert.equal(argv[12], dir);
     assert.match(argsText, /Output contract/);
     assert.equal(readFileSync(stdinFile, 'utf8'), 'long enough turn text');
   } finally {

package/src/handoff-executor.mjs

@@ -0,0 +1,161 @@
+/**
+ * handoff-executor.mjs — 最初の UserPromptSubmit で実行する引き継ぎ本体
+ *
+ * 二相ハンドオフ (ADR 0014) の第二相。SessionStart が登録した pending intent を
+ * 消費し、baton path 優先 → auto path の順で前任を merge して、予算内の
+ * resume context を組み立てて返す。呼び出し元 (prompt-submit) が stdout へ書く。
+ *
+ * 幽霊セッション (transcript を生成しない SessionStart) はプロンプトを発火しない
+ * ため、この経路に到達できない。= バトンも auto 前任も実体のあるセッションだけが
+ * 受け取れる。
+ */
+
+import { existsSync } from 'node:fs';
+import { consumeBaton } from './baton.mjs';
+import { consumePendingHandoff } from './pending-handoff.mjs';
+import { mergeSpecificPredecessor, resolveMergeTarget } from './session-merger.mjs';
+import { backfillBodies, deriveTranscriptPath, logBackfill } from './turn-backfill.mjs';
+import { buildBudgetedResumeContext } from './resume-context.mjs';
+import { readAllSessionStates } from './state-file.mjs';
+
+/**
+ * @param {import('node:sqlite').DatabaseSync} db
+ * @param {{ sessionId: string, projectPath: string, now?: number }} params
+ * @returns {{
+ *   attempted: boolean,            // pending 行が存在した (= newborn の初回プロンプト)
+ *   triggeredPath: 'baton' | 'auto' | null,
+ *   baton: object | null,          // consumeBaton の生返り値 (ログ用)
+ *   pendingCreatedAt: number | null,
+ *   mergeResult: object,           // mergeSpecificPredecessor の返り値 or skip
+ *   injectionText: string | null,  // 予算内注入テキスト (merge 成立時のみ)
+ *   injectionStats: object | null, // dropped counts 等 (ログ用)
+ * }}
+ */
+export function executeFirstPromptHandoff(db, { sessionId, projectPath, now = Date.now() }) {
+  const pending = consumePendingHandoff(db, { sessionId });
+  if (!pending) {
+    return {
+      attempted: false,
+      triggeredPath: null,
+      baton: null,
+      pendingCreatedAt: null,
+      mergeResult: { merged: false, skipReason: 'not_newborn' },
+      injectionText: null,
+      injectionStats: null,
+    };
+  }
+
+  // baton 適格性はセッション誕生時刻 (pending.createdAt) 基準。
+  // 誕生後に書かれたバトンは future_baton として残置される (本来の後継のもの)。
+  const baton = consumeBaton(db, { projectPath, now, bornAt: pending.createdAt });
+
+  let triggeredPath = null;
+  let mergeResult = { merged: false, skipReason: 'no_trigger' };
+
+  if (baton.sessionId) {
+    triggeredPath = 'baton';
+    const { target: predecessorId } = resolveMergeTarget(db, baton.sessionId);
+    mergeResult = mergeSpecificPredecessor(db, {
+      newSessionId: sessionId,
+      predecessorId,
+      now,
+    });
+  } else if (pending.autoPredecessorId) {
+    triggeredPath = 'auto';
+    const { target: predecessorId } = resolveMergeTarget(db, pending.autoPredecessorId);
+    mergeResult = mergeSpecificPredecessor(db, {
+      newSessionId: sessionId,
+      predecessorId,
+      now,
+    });
+  }
+
+  let injectionText = null;
+  let injectionStats = null;
+
+  if (mergeResult.merged) {
+    const predecessorId = mergeResult.predecessorId;
+    // /clear 直前ターンの取りこぼしを注入前に回収する。前任の transcript path は
+    // project path から決定的に導出する — state ファイルは Stop 不発の前任
+    // (まさに回収したい事例) では存在しないため補助。
+    const derivedTranscriptPath = deriveTranscriptPath(projectPath, predecessorId);
+    const stateTranscriptPath = readAllSessionStates().find(
+      (state) => state.sessionId === predecessorId,
+    )?.transcriptPath;
+    const predecessorTranscriptPath = existsSync(derivedTranscriptPath)
+      ? derivedTranscriptPath
+      : stateTranscriptPath && existsSync(stateTranscriptPath)
+        ? stateTranscriptPath
+        : null;
+
+    if (predecessorTranscriptPath) {
+      try {
+        const backfill = backfillBodies(db, {
+          targetSessionId: sessionId,
+          originSessionId: predecessorId,
+          transcriptPath: predecessorTranscriptPath,
+          now,
+        });
+        logBackfill({
+          ts: new Date(now).toISOString(),
+          hook: 'prompt-submit',
+          session_id: sessionId,
+          target: sessionId,
+          origin: predecessorId,
+          transcript_path: predecessorTranscriptPath,
+          groups: backfill.groups,
+          inserted_turns: backfill.insertedTurns,
+          skipped_existing: backfill.skippedExisting,
+        });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[prompt-submit:backfill] ${message}\n`);
+        logBackfill({
+          ts: new Date(now).toISOString(),
+          hook: 'prompt-submit',
+          session_id: sessionId,
+          target: sessionId,
+          origin: predecessorId,
+          transcript_path: predecessorTranscriptPath,
+          error: message,
+        });
+      }
+    } else {
+      logBackfill({
+        ts: new Date(now).toISOString(),
+        hook: 'prompt-submit',
+        session_id: sessionId,
+        target: sessionId,
+        origin: predecessorId,
+        transcript_path: null,
+        skip_reason: 'no_transcript_path',
+      });
+    }
+
+    const budgeted = buildBudgetedResumeContext(db, {
+      sessionId,
+      isInheritance: true,
+    });
+    if (budgeted) {
+      injectionText = budgeted.text;
+      injectionStats = {
+        total_chars: budgeted.totalChars,
+        injected_l2_turns: budgeted.injectedL2Turns,
+        remaining_l2_turns: budgeted.remainingL2Turns,
+        older_turns: budgeted.olderTurns,
+        older_summarized: budgeted.olderSummarized,
+        truncated_newest_l2: budgeted.truncatedNewestL2,
+      };
+    }
+  }
+
+  return {
+    attempted: true,
+    triggeredPath,
+    baton,
+    pendingCreatedAt: pending.createdAt,
+    mergeResult,
+    injectionText,
+    injectionStats,
+  };
+}