bitbank-lab-mcp 0.1.0

package/tools/analyze_mtf_fibonacci.ts

@@ -0,0 +1,273 @@
+import { z } from 'zod';
+import { formatPair, formatPercent, formatPrice } from '../lib/formatter.js';
+import { failFromError, failFromValidation } from '../lib/result.js';
+import { createMeta, ensurePair } from '../lib/validate.js';
+import { AnalyzeMtfFibonacciInputSchema as _BaseInputSchema, AnalyzeMtfFibonacciOutputSchema } from '../src/schemas.js';
+import analyzeFibonacci from './analyze_fibonacci.js';
+
+const AnalyzeMtfFibonacciInputSchema = _BaseInputSchema.extend({
+	lookbackDays: z.array(z.number().int().min(14).max(365)).nonempty().optional().default([30, 90, 180]),
+});
+
+import type { Pair } from '../src/schemas.js';
+import type { ToolDefinition } from '../src/tool-definition.js';
+
+// ── Types ──
+
+interface FibLevel {
+	ratio: number;
+	price: number;
+	distancePct: number;
+	isNearest: boolean;
+}
+
+interface ConfluenceZone {
+	priceZone: [number, number];
+	matchedLevels: Array<{ lookbackDays: number; ratio: number; price: number }>;
+	strength: 'strong' | 'moderate' | 'weak';
+	distancePct: number;
+}
+
+// ── Confluence Detection ──
+
+/**
+ * Find price zones where Fibonacci levels from different lookback periods cluster together.
+ * A confluence zone indicates stronger support/resistance.
+ */
+function detectConfluence(
+	periodResults: Array<{ lookbackDays: number; levels: FibLevel[] }>,
+	currentPrice: number,
+	tolerancePct: number = 1.0,
+): ConfluenceZone[] {
+	// Collect all levels from all periods
+	const allLevels: Array<{ lookbackDays: number; ratio: number; price: number }> = [];
+
+	for (const period of periodResults) {
+		for (const level of period.levels) {
+			// Skip 0% and 100% as they are just swing points
+			if (level.ratio === 0 || level.ratio === 1.0) continue;
+			allLevels.push({
+				lookbackDays: period.lookbackDays,
+				ratio: level.ratio,
+				price: level.price,
+			});
+		}
+	}
+
+	if (allLevels.length < 2) return [];
+
+	// Sort by price
+	const sorted = [...allLevels].sort((a, b) => a.price - b.price);
+
+	// Cluster nearby levels using tolerance
+	const zones: ConfluenceZone[] = [];
+	const used = new Set<number>();
+
+	for (let i = 0; i < sorted.length; i++) {
+		if (used.has(i)) continue;
+
+		const cluster = [sorted[i]];
+		used.add(i);
+
+		for (let j = i + 1; j < sorted.length; j++) {
+			if (used.has(j)) continue;
+
+			const avgPrice = cluster.reduce((s, c) => s + c.price, 0) / cluster.length;
+			const pctDiff = (Math.abs(sorted[j].price - avgPrice) / avgPrice) * 100;
+
+			if (pctDiff <= tolerancePct) {
+				cluster.push(sorted[j]);
+				used.add(j);
+			}
+		}
+
+		// Only consider as confluence if levels from at least 2 different periods match
+		const uniquePeriods = new Set(cluster.map((c) => c.lookbackDays));
+		if (uniquePeriods.size < 2) continue;
+
+		const prices = cluster.map((c) => c.price);
+		const zoneMin = Math.min(...prices);
+		const zoneMax = Math.max(...prices);
+		const zoneCenter = (zoneMin + zoneMax) / 2;
+		const distancePct = ((zoneCenter - currentPrice) / currentPrice) * 100;
+
+		const strength: 'strong' | 'moderate' | 'weak' =
+			uniquePeriods.size >= 3 ? 'strong' : uniquePeriods.size >= 2 && cluster.length >= 3 ? 'moderate' : 'weak';
+
+		zones.push({
+			priceZone: [Math.round(zoneMin), Math.round(zoneMax)],
+			matchedLevels: cluster,
+			strength,
+			distancePct: Number(distancePct.toFixed(2)),
+		});
+	}
+
+	// Sort by distance from current price
+	zones.sort((a, b) => Math.abs(a.distancePct) - Math.abs(b.distancePct));
+
+	return zones;
+}
+
+// ── Content Generation ──
+
+function generateMtfContent(
+	pair: string,
+	currentPrice: number,
+	periodResults: Array<{ lookbackDays: number; data: Record<string, unknown> }>,
+	confluence: ConfluenceZone[],
+): Array<{ type: 'text'; text: string }> {
+	const lines: string[] = [];
+	const pairLabel = formatPair(pair);
+
+	lines.push(`【マルチタイムフレーム・フィボナッチ分析】${pairLabel}`);
+	lines.push(`現在価格: ${formatPrice(currentPrice, pair)}`);
+	lines.push('');
+
+	// Per-period summaries
+	for (const pr of periodResults) {
+		const d = pr.data;
+		const swingHigh = d.swingHigh as { price: number; date: string };
+		const swingLow = d.swingLow as { price: number; date: string };
+		lines.push(`--- ${pr.lookbackDays}日 ---`);
+		lines.push(`  トレンド: ${d.trend === 'up' ? '上昇↑' : '下降↓'}`);
+		lines.push(`  スイングハイ: ${formatPrice(swingHigh.price, pair)}（${swingHigh.date}）`);
+		lines.push(`  スイングロー: ${formatPrice(swingLow.price, pair)}（${swingLow.date}）`);
+
+		// All retracement levels (0% and 100% are swing points, still useful for reference)
+		const allLevels = (d.levels as FibLevel[]) ?? [];
+		for (const kl of allLevels) {
+			const nearest = kl.isNearest ? ' ← 最寄り' : '';
+			lines.push(
+				`  ${(kl.ratio * 100).toFixed(1)}%: ${formatPrice(kl.price, pair)} (${formatPercent(kl.distancePct, { sign: true })})${nearest}`,
+			);
+		}
+		lines.push('');
+	}
+
+	// Confluence zones
+	if (confluence.length > 0) {
+		lines.push('【コンフルエンス（合流）ゾーン】');
+		for (const zone of confluence) {
+			const strengthJa = zone.strength === 'strong' ? '強' : zone.strength === 'moderate' ? '中' : '弱';
+			lines.push(
+				`  ${formatPrice(zone.priceZone[0], pair)} 〜 ${formatPrice(zone.priceZone[1], pair)} (${formatPercent(zone.distancePct, { sign: true })}) [信頼度: ${strengthJa}]`,
+			);
+			for (const ml of zone.matchedLevels) {
+				lines.push(`    - ${ml.lookbackDays}日: ${(ml.ratio * 100).toFixed(1)}% = ${formatPrice(ml.price, pair)}`);
+			}
+		}
+		lines.push('');
+	} else {
+		lines.push('【コンフルエンス】合流ゾーンは検出されませんでした');
+		lines.push('');
+	}
+
+	lines.push('【判定ロジック】');
+	lines.push('- 各ルックバック期間で独立にスイング検出・フィボナッチ水準を算出');
+	lines.push('- 異なる期間の水準が±1%以内に集中する「合流ゾーン」を検出');
+	lines.push('- 3期間以上の合流 → 信頼度「強」、2期間の合流 → 信頼度「中〜弱」');
+
+	return [{ type: 'text', text: lines.join('\n') }];
+}
+
+// ── Main Handler ──
+
+export default async function analyzeMtfFibonacci(pair: string = 'btc_jpy', lookbackDays: number[] = [30, 90, 180]) {
+	const chk = ensurePair(pair);
+	if (!chk.ok) return failFromValidation(chk, AnalyzeMtfFibonacciOutputSchema);
+
+	try {
+		// Deduplicate lookback periods
+		const uniqueDays = [...new Set(lookbackDays)];
+
+		// Run all lookback periods in parallel
+		const results = await Promise.all(
+			uniqueDays.map(async (days) => {
+				const res = await analyzeFibonacci({
+					pair: chk.pair,
+					type: '1day',
+					lookbackDays: days,
+					mode: 'retracement',
+					historyLookbackDays: days,
+				});
+				return { lookbackDays: days, result: res as Record<string, unknown> };
+			}),
+		);
+
+		// Build per-period data
+		const periods: Record<string, unknown> = {};
+		const periodSummaries: Array<{ lookbackDays: number; data: Record<string, unknown>; levels: FibLevel[] }> = [];
+		let currentPrice = 0;
+
+		for (const { lookbackDays: days, result } of results) {
+			if (result?.ok && result?.data) {
+				const d = result.data as Record<string, unknown>;
+				const swingHigh = d.swingHigh as { price: number; date: string };
+				const swingLow = d.swingLow as { price: number; date: string };
+				const levels = (d.levels as FibLevel[]) ?? [];
+				periods[String(days)] = {
+					lookbackDays: days,
+					trend: d.trend,
+					swingHigh: { price: swingHigh.price, date: swingHigh.date },
+					swingLow: { price: swingLow.price, date: swingLow.date },
+					levels,
+				};
+				periodSummaries.push({ lookbackDays: days, data: d, levels });
+				if (d.currentPrice) currentPrice = d.currentPrice as number;
+			} else {
+				periods[String(days)] = {
+					lookbackDays: days,
+					trend: 'down',
+					swingHigh: { price: 0, date: '' },
+					swingLow: { price: 0, date: '' },
+					levels: [],
+				};
+			}
+		}
+
+		// Detect confluence
+		const confluenceInput = periodSummaries.map((ps) => ({
+			lookbackDays: ps.lookbackDays,
+			levels: ps.levels,
+		}));
+		const confluence = detectConfluence(confluenceInput, currentPrice);
+
+		// Generate content
+		const content = generateMtfContent(chk.pair, currentPrice, periodSummaries, confluence);
+
+		const confluenceCount = confluence.length;
+		const strongCount = confluence.filter((z) => z.strength === 'strong').length;
+		const summaryText =
+			confluenceCount > 0
+				? `${formatPair(chk.pair)} MTFフィボナッチ: ${confluenceCount}個の合流ゾーン検出（強: ${strongCount}個）`
+				: `${formatPair(chk.pair)} MTFフィボナッチ: 合流ゾーンなし（各期間の水準が分散）`;
+
+		const data = {
+			pair: chk.pair,
+			currentPrice,
+			periods,
+			confluence,
+		};
+
+		const meta = createMeta(chk.pair as Pair, { lookbackDays: uniqueDays });
+
+		return AnalyzeMtfFibonacciOutputSchema.parse({
+			ok: true,
+			summary: summaryText,
+			content,
+			data,
+			meta,
+		});
+	} catch (e: unknown) {
+		return failFromError(e, { schema: AnalyzeMtfFibonacciOutputSchema });
+	}
+}
+
+// ── MCP ツール定義（tool-registry から自動収集） ──
+export const toolDef: ToolDefinition = {
+	name: 'analyze_mtf_fibonacci',
+	description: `[Multi-Timeframe Fibonacci / Confluence] 複数期間フィボナッチ一括分析（MTF fibonacci / confluence zone）。複数ルックバック期間の水準を並列計算し、コンフルエンス（合流）ゾーンを自動検出。analyze_fibonacci を個別に呼ぶ必要なし。`,
+	inputSchema: AnalyzeMtfFibonacciInputSchema,
+	handler: async ({ pair, lookbackDays }: { pair?: string; lookbackDays?: number[] }) =>
+		analyzeMtfFibonacci(pair, lookbackDays),
+};

package/tools/analyze_mtf_sma.ts

@@ -0,0 +1,175 @@
+import type { z } from 'zod';
+import { failFromError, failFromValidation, ok } from '../lib/result.js';
+import { createMeta, ensurePair } from '../lib/validate.js';
+import {
+	type AnalyzeMtfSmaDataSchemaOut,
+	AnalyzeMtfSmaInputSchema,
+	type AnalyzeMtfSmaMetaSchemaOut,
+	AnalyzeMtfSmaOutputSchema,
+} from '../src/schemas.js';
+import type { ToolDefinition } from '../src/tool-definition.js';
+import analyzeSmaSnapshot from './analyze_sma_snapshot.js';
+
+const ALIGNMENT_ICON: Record<string, string> = {
+	bullish: '🟢',
+	bearish: '🔴',
+	mixed: '🟡',
+	unknown: '⚪',
+};
+
+/** 単調減少なら "25>75>200"、単調増加なら "200>75>25"、それ以外は "mixed"。 */
+function deriveSmaOrder(periods: number[], smaMap: Record<string, number | null> | undefined): string {
+	if (!smaMap) return 'mixed';
+	const uniq = [...new Set(periods)].sort((a, b) => a - b);
+	const vals = uniq.map((p) => smaMap[`SMA_${p}`]);
+	if (vals.some((v) => v == null || !Number.isFinite(v))) return 'mixed';
+	const nums = vals as number[];
+	const allDesc = nums.every((v, i) => i === 0 || v < nums[i - 1]);
+	const allAsc = nums.every((v, i) => i === 0 || v > nums[i - 1]);
+	if (allDesc) return uniq.join('>');
+	if (allAsc) return [...uniq].reverse().join('>');
+	return 'mixed';
+}
+
+export default async function analyzeMtfSma(
+	pair: string = 'btc_jpy',
+	timeframes: string[] = ['1hour', '4hour', '1day'],
+	periods: number[] = [25, 75, 200],
+) {
+	const chk = ensurePair(pair);
+	if (!chk.ok) return failFromValidation(chk, AnalyzeMtfSmaOutputSchema);
+
+	try {
+		// Deduplicate timeframes to avoid redundant calls
+		const uniqueTimeframes = [...new Set(timeframes)];
+
+		// Run all timeframes in parallel — each triggers analyzeIndicators
+		// which has a 30s TTL cache, so same pair+type won't re-fetch.
+		const results = await Promise.all(
+			uniqueTimeframes.map(async (tf) => {
+				const res = await analyzeSmaSnapshot(chk.pair, tf, 220, periods);
+				return { timeframe: tf, result: res as Record<string, unknown> };
+			}),
+		);
+
+		// Build per-timeframe results (pick fields relevant to MTF view)
+		const byTimeframe: Record<string, unknown> = {};
+		const alignments: string[] = [];
+
+		for (const { timeframe, result } of results) {
+			if (result?.ok && result?.data) {
+				const d = result.data as Record<string, unknown>;
+				const summary = d.summary as Record<string, unknown> | undefined;
+				const alignment = d.alignment as string;
+				const latest = d.latest as { close: number | null } | undefined;
+				const smaMap = d.sma as Record<string, number | null> | undefined;
+				byTimeframe[timeframe] = {
+					alignment,
+					alignmentIcon: ALIGNMENT_ICON[alignment] ?? '⚪',
+					position: (summary?.position as string) ?? 'unknown',
+					price: latest?.close ?? null,
+					latest: latest ?? { close: null },
+					sma: smaMap,
+					smas: d.smas,
+					smaOrder: deriveSmaOrder(periods, smaMap),
+					crosses: d.crosses,
+					recentCrosses: d.recentCrosses,
+					tags: d.tags,
+				};
+				alignments.push(alignment);
+			} else {
+				byTimeframe[timeframe] = {
+					alignment: 'unknown',
+					alignmentIcon: ALIGNMENT_ICON.unknown,
+					position: 'unknown',
+					price: null,
+					latest: { close: null },
+					smaOrder: 'mixed',
+					recentCrosses: [],
+				};
+				alignments.push('unknown');
+			}
+		}
+
+		// Confluence judgment — any unknown in requested timeframes → aligned=false, direction=unknown
+		let direction: 'bullish' | 'bearish' | 'mixed' | 'unknown';
+		let aligned: boolean;
+
+		if (alignments.some((a) => a === 'unknown')) {
+			direction = 'unknown';
+			aligned = false;
+		} else if (alignments.every((a) => a === 'bullish')) {
+			direction = 'bullish';
+			aligned = true;
+		} else if (alignments.every((a) => a === 'bearish')) {
+			direction = 'bearish';
+			aligned = true;
+		} else {
+			direction = 'mixed';
+			aligned = false;
+		}
+
+		const dirLabel = direction === 'bullish' ? '上昇' : direction === 'bearish' ? '下降' : '混合';
+		const tfEntry = (tf: string) => byTimeframe[tf] as Record<string, unknown> | undefined;
+		const summary = aligned
+			? `全時間軸が${dirLabel}方向で一致`
+			: `時間軸間で方向が分かれている（${timeframes.map((tf) => `${tf}:${tfEntry(tf)?.alignment}`).join(', ')})`;
+
+		const summaryText = `${timeframes.map((tf) => `${tf}: ${tfEntry(tf)?.alignment}`).join(' / ')} → ${summary}`;
+
+		const data: z.infer<typeof AnalyzeMtfSmaDataSchemaOut> = {
+			timeframes: byTimeframe as z.infer<typeof AnalyzeMtfSmaDataSchemaOut>['timeframes'],
+			confluence: { aligned, direction, summary },
+		};
+
+		const meta = createMeta(chk.pair, { timeframes, periods }) as z.infer<typeof AnalyzeMtfSmaMetaSchemaOut>;
+		return AnalyzeMtfSmaOutputSchema.parse(ok(summaryText, data, meta));
+	} catch (e: unknown) {
+		return failFromError(e, { schema: AnalyzeMtfSmaOutputSchema });
+	}
+}
+
+type MtfSmaEntry = z.infer<typeof AnalyzeMtfSmaDataSchemaOut>['timeframes'][string];
+
+/** timeframe 1件分の構造化要約を組み立てる（LLM が content テキストから詳細表示を組めるよう） */
+function buildTimeframeLine(tf: string, entry: MtfSmaEntry | undefined): string {
+	if (!entry) return `${tf}: no data`;
+	const ent = entry as unknown as Record<string, unknown>;
+	const icon = (ent.alignmentIcon as string) ?? '';
+	const alignment = ent.alignment as string;
+	const price = ent.price as number | null;
+	const smaOrder = (ent.smaOrder as string) ?? 'mixed';
+	const smas = (ent.smas ?? {}) as Record<string, Record<string, unknown>>;
+	const smaParts = Object.entries(smas).map(([period, info]) => {
+		const value = info.value;
+		const pos = info.pricePosition ? (info.pricePosition === 'above' ? '▲' : '▼') : '=';
+		const devStr =
+			info.distancePct != null ? ` (${(info.distancePct as number) >= 0 ? '+' : ''}${info.distancePct}%)` : '';
+		const slope = info.slope ? ` slope=${info.slope}` : '';
+		return `SMA${period}=${value ?? 'n/a'} ${pos}${devStr}${slope}`;
+	});
+	const recent = (ent.recentCrosses ?? []) as Array<{ type: string; pair: [number, number]; barsAgo: number }>;
+	const recentStr =
+		recent.length > 0
+			? ` / recent: ${recent.map((r) => `${r.type}(${r.pair.join('/')}, ${r.barsAgo}ago)`).join(', ')}`
+			: '';
+	return `${tf} ${icon} ${alignment} price=${price ?? 'n/a'} order=${smaOrder}\n    ${smaParts.join(' | ')}${recentStr}`;
+}
+
+// ── MCP ツール定義（tool-registry から自動収集） ──
+export const toolDef: ToolDefinition = {
+	name: 'analyze_mtf_sma',
+	description:
+		'[Multi-Timeframe SMA / MTF] 複数タイムフレームSMA一括分析（multi-timeframe / MTF / SMA alignment / confluence）。整列方向とコンフルエンスを判定。',
+	inputSchema: AnalyzeMtfSmaInputSchema,
+	handler: async ({ pair, timeframes, periods }: { pair?: string; timeframes?: string[]; periods?: number[] }) => {
+		const res = await analyzeMtfSma(pair, timeframes, periods);
+		if (!res?.ok) return res;
+		const requestedTfs = timeframes ?? ['1hour', '4hour', '1day'];
+		const lines = requestedTfs.map((tf) => buildTimeframeLine(tf, res.data.timeframes[tf]));
+		const conf = res.data.confluence;
+		const confLine = `Confluence: aligned=${conf.aligned} direction=${conf.direction} — ${conf.summary}`;
+		const text = `${res.summary}\n\n${lines.join('\n')}\n\n${confLine}`;
+		return { content: [{ type: 'text', text }], structuredContent: res as unknown as Record<string, unknown> };
+	},
+};

package/tools/analyze_sma_snapshot.ts

@@ -0,0 +1,146 @@
+import type { z } from 'zod';
+import { formatSummary } from '../lib/formatter.js';
+import {
+	buildMaLines,
+	buildMaSnapshotText,
+	type CrossStatus,
+	computeMaExt,
+	detectAlignment,
+	detectCrossStatuses,
+	detectPosition,
+	detectRecentCrosses,
+	generateCrossPairs,
+	getSeries,
+	type MaExtEntry,
+	type MaLineEntry,
+	type RecentCrossEntry,
+} from '../lib/ma-snapshot-utils.js';
+import { fail, failFromError, failFromValidation, ok } from '../lib/result.js';
+import { createMeta, ensurePair } from '../lib/validate.js';
+import {
+	type AnalyzeSmaSnapshotDataSchemaOut,
+	AnalyzeSmaSnapshotInputSchema,
+	AnalyzeSmaSnapshotOutputSchema,
+} from '../src/schemas.js';
+import type { ToolDefinition } from '../src/tool-definition.js';
+import analyzeIndicators from './analyze_indicators.js';
+
+export type { CrossStatus, MaLineEntry, RecentCrossEntry };
+
+export interface BuildSmaSnapshotTextInput {
+	baseSummary: string;
+	type: string;
+	maLines: MaLineEntry[];
+	crossStatuses: CrossStatus[];
+	recentCrosses: RecentCrossEntry[];
+}
+
+const SMA_FOOTER = [
+	'📌 含まれるもの: SMA値・傾き・クロス状態・配列パターン・価格との乖離',
+	'📌 含まれないもの: 他のテクニカル指標（RSI・MACD・BB・一目均衡表）、出来高フロー、板情報',
+	'📌 補完ツール: analyze_indicators（他指標）, analyze_bb_snapshot（BB）, get_flow_metrics（出来高）, get_orderbook（板情報）',
+];
+
+/** テキスト組み立て（SMAスナップショット）— テスト可能な純粋関数 */
+export function buildSmaSnapshotText(input: BuildSmaSnapshotTextInput): string {
+	return buildMaSnapshotText({ ...input, prefix: 'SMA', footerLines: SMA_FOOTER });
+}
+
+export default async function analyzeSmaSnapshot(
+	pair: string = 'btc_jpy',
+	type: string = '1day',
+	limit: number = 220,
+	periods: number[] = [25, 75, 200],
+) {
+	const chk = ensurePair(pair);
+	if (!chk.ok) return failFromValidation(chk, AnalyzeSmaSnapshotOutputSchema);
+	try {
+		const indRes = await analyzeIndicators(chk.pair, type, Math.max(Math.max(...periods, 200), limit));
+		if (!indRes.ok)
+			return AnalyzeSmaSnapshotOutputSchema.parse(
+				fail(indRes.summary || 'indicators failed', indRes.meta.errorType || 'internal'),
+			);
+
+		const close = indRes.data.normalized.at(-1)?.close ?? null;
+		const map: Record<string, number | null> = {};
+		const indRecord = indRes.data.indicators as Record<string, number[] | number | null>;
+		const get = (p: number) => (indRecord[`SMA_${p}`] as number | null) ?? null;
+		for (const p of periods) map[`SMA_${p}`] = get(p);
+
+		const chartInd: Record<string, unknown> = indRes?.data?.chart?.indicators ?? {};
+		const candles: Array<{ isoTime?: string | null }> = Array.isArray(indRes?.data?.chart?.candles)
+			? indRes.data.chart.candles
+			: Array.isArray(indRes?.data?.normalized)
+				? indRes.data.normalized
+				: [];
+
+		const crossPairs = generateCrossPairs(periods);
+		const crosses = detectCrossStatuses(crossPairs, map, 'SMA');
+		const recentCrosses = detectRecentCrosses(crossPairs, chartInd, candles, 'SMA');
+
+		const sortedPeriods = [...new Set(periods)].sort((a, b) => a - b);
+		const sortedVals = sortedPeriods.map((p) => map[`SMA_${p}`]);
+		const alignment = detectAlignment(sortedVals, { minPeriods: 2, strict: true });
+
+		const tags: string[] = [];
+		if (alignment === 'bullish') tags.push('sma_bullish_alignment');
+		if (alignment === 'bearish') tags.push('sma_bearish_alignment');
+
+		const smaVals = periods.map((p) => map[`SMA_${p}`]).filter((v): v is number => v != null);
+		const position = detectPosition(close, smaVals);
+
+		const smasExt: Record<string, MaExtEntry> = {};
+		for (const p of periods) {
+			const val = map[`SMA_${p}`];
+			const series = getSeries(chartInd, 'SMA', p);
+			smasExt[String(p)] = computeMaExt(close, val, series, type);
+		}
+
+		const maLines = buildMaLines(periods, smasExt);
+		const summaryText = buildSmaSnapshotText({
+			baseSummary: formatSummary({
+				pair: chk.pair,
+				latest: close ?? undefined,
+				extra: `align=${alignment} pos=${position}`,
+			}),
+			type,
+			maLines,
+			crossStatuses: crosses,
+			recentCrosses,
+		});
+
+		const data: z.infer<typeof AnalyzeSmaSnapshotDataSchemaOut> = {
+			latest: { close },
+			sma: map,
+			crosses,
+			alignment,
+			tags,
+			summary: { close, align: alignment, position },
+			smas: smasExt,
+			recentCrosses,
+		};
+		const meta = createMeta(chk.pair, { type, count: indRes.data.normalized.length, periods });
+		return AnalyzeSmaSnapshotOutputSchema.parse(ok(summaryText, data, meta));
+	} catch (e: unknown) {
+		return failFromError(e, { schema: AnalyzeSmaSnapshotOutputSchema });
+	}
+}
+
+// ── MCP ツール定義（tool-registry から自動収集） ──
+export const toolDef: ToolDefinition = {
+	name: 'analyze_sma_snapshot',
+	description:
+		'[SMA / Moving Average / Golden Cross] SMA（simple moving average / golden cross / dead cross）の数値スナップショット。最新値・クロス検出・整列状態（bullish/bearish/mixed）。\n\n⚠️ 最新値のみ。時系列チャート描画 → prepare_chart_data（indicators: ["SMA_25","SMA_75"] 等）。',
+	inputSchema: AnalyzeSmaSnapshotInputSchema,
+	handler: async ({
+		pair,
+		type,
+		limit,
+		periods,
+	}: {
+		pair?: string;
+		type?: string;
+		limit?: number;
+		periods?: number[];
+	}) => analyzeSmaSnapshot(pair, type, limit, periods),
+};