bitbank-lab-mcp 0.1.0

package/tools/get_volatility_metrics.ts

@@ -0,0 +1,302 @@
+import type { z } from 'zod';
+import { toNum } from '../lib/conversions.js';
+import { nowIso } from '../lib/datetime.js';
+import { formatSummary } from '../lib/formatter.js';
+import { trueRange } from '../lib/indicators.js';
+import { slidingMean, slidingStddev, stddev } from '../lib/math.js';
+import { fail, failFromError, failFromValidation, ok } from '../lib/result.js';
+import { createMeta, ensurePair, validateLimit } from '../lib/validate.js';
+import {
+	componentMeanToVol,
+	garmanKlassComponents,
+	logReturns,
+	parkinsonComponents,
+	rogersSatchellComponents,
+} from '../lib/volatility.js';
+import {
+	type GetVolMetricsDataSchemaOut,
+	type GetVolMetricsMetaSchemaOut,
+	GetVolMetricsOutputSchema,
+} from '../src/schemas.js';
+import getCandles from './get_candles.js';
+
+type Candle = { open: number; high: number; low: number; close: number; isoTime?: string | null };
+
+export interface RollingEntry {
+	window: number;
+	rv_std: number;
+	rv_std_ann?: number;
+	atr?: number;
+	parkinson?: number;
+	garmanKlass?: number;
+	rogersSatchell?: number;
+}
+
+export interface BuildVolatilityMetricsTextInput {
+	baseSummary: string;
+	aggregates: {
+		rv_std: number;
+		rv_std_ann?: number;
+		parkinson: number;
+		garmanKlass: number;
+		rogersSatchell: number;
+		atr: number;
+	};
+	rolling: RollingEntry[];
+}
+
+/** テキスト組み立て（ボラティリティ詳細）— テスト可能な純粋関数 */
+export function buildVolatilityMetricsText(input: BuildVolatilityMetricsTextInput): string {
+	const { baseSummary, aggregates: a, rolling } = input;
+	const aggLines = [
+		`rv_std:${a.rv_std}`,
+		a.rv_std_ann != null ? `rv_std_ann:${a.rv_std_ann}` : '',
+		`parkinson:${a.parkinson}`,
+		`garmanKlass:${a.garmanKlass}`,
+		`rogersSatchell:${a.rogersSatchell}`,
+		`atr:${a.atr}`,
+	]
+		.filter(Boolean)
+		.join(' ');
+	const rollLines = rolling.map((r) => {
+		const parts = [`w=${r.window} rv:${r.rv_std.toFixed(6)}`];
+		if (r.rv_std_ann != null) parts.push(`ann:${r.rv_std_ann.toFixed(6)}`);
+		if (r.atr != null) parts.push(`atr:${r.atr.toFixed(2)}`);
+		if (r.parkinson != null) parts.push(`pk:${r.parkinson.toFixed(6)}`);
+		return parts.join(' ');
+	});
+	return (
+		baseSummary +
+		`\n\naggregates: ${aggLines}` +
+		`\n\n📊 ローリング分析:\n` +
+		rollLines.join('\n') +
+		`\n\n---\n📌 含まれるもの: ボラティリティ指標（RV・Parkinson・GK・RS・ATR）、ローリング分析` +
+		`\n📌 含まれないもの: 価格の方向性・トレンド、出来高フロー、板情報、テクニカル指標` +
+		`\n📌 補完ツール: get_candles（価格OHLCV）, analyze_indicators（方向性指標）, get_flow_metrics（出来高フロー）`
+	);
+}
+
+function baseIntervalMsOf(type: string): number {
+	switch (type) {
+		case '1min':
+			return 60_000;
+		case '5min':
+			return 5 * 60_000;
+		case '15min':
+			return 15 * 60_000;
+		case '30min':
+			return 30 * 60_000;
+		case '1hour':
+			return 60 * 60_000;
+		case '4hour':
+			return 4 * 60 * 60_000;
+		case '8hour':
+			return 8 * 60 * 60_000;
+		case '12hour':
+			return 12 * 60 * 60_000;
+		case '1day':
+			return 24 * 60 * 60_000;
+		case '1week':
+			return 7 * 24 * 60 * 60_000;
+		case '1month':
+			return 30 * 24 * 60 * 60_000; // approx
+		default:
+			return 24 * 60 * 60_000;
+	}
+}
+
+function periodsPerYear(type: string): number {
+	const secondsPerYear = 365 * 24 * 60 * 60;
+	const intervalSec = baseIntervalMsOf(type) / 1000;
+	return Math.max(1, Math.floor(secondsPerYear / intervalSec));
+}
+
+function toMs(iso: string | null | undefined): number | null {
+	if (!iso) return null;
+	return toNum(Date.parse(iso));
+}
+
+export default async function getVolatilityMetrics(
+	pair: string,
+	type: string = '1day',
+	limit: number = 200,
+	windows: number[] = [14, 20, 30],
+	opts?: { useLogReturns?: boolean; annualize?: boolean; tz?: string; cacheTtlMs?: number },
+) {
+	const chk = ensurePair(pair);
+	if (!chk.ok) return failFromValidation(chk, GetVolMetricsOutputSchema);
+	const lim = validateLimit(limit, 20, 500);
+	if (!lim.ok) return failFromValidation(lim, GetVolMetricsOutputSchema);
+
+	try {
+		const cRes = await getCandles(chk.pair, type, undefined, lim.value);
+		if (!cRes.ok)
+			return GetVolMetricsOutputSchema.parse(fail(cRes.summary || 'failed', cRes.meta.errorType || 'internal'));
+		const candles: Candle[] = cRes.data.normalized;
+		if (!Array.isArray(candles) || candles.length < 20) {
+			return GetVolMetricsOutputSchema.parse(fail('データ不足（最低20本必要）', 'user'));
+		}
+
+		const useLog = opts?.useLogReturns ?? true;
+		const withAnn = opts?.annualize ?? true;
+
+		const ts: number[] = [];
+		const close: number[] = [];
+		const open: number[] = [];
+		const high: number[] = [];
+		const low: number[] = [];
+		for (const c of candles) {
+			const o = toNum(c.open);
+			const h = toNum(c.high);
+			const l = toNum(c.low);
+			const cl = toNum(c.close);
+			if (o == null || h == null || l == null || cl == null) continue;
+
+			const t = toMs(c.isoTime ?? null);
+			if (t != null) ts.push(t);
+			else ts.push(ts.length > 0 ? ts[ts.length - 1] + baseIntervalMsOf(type) : Date.now());
+			open.push(o);
+			high.push(h);
+			low.push(l);
+			close.push(cl);
+		}
+
+		if (close.length < 20) {
+			return GetVolMetricsOutputSchema.parse(fail('有効なOHLCデータ不足（最低20本必要）', 'user'));
+		}
+
+		const ret = logReturns(close, useLog);
+		const rvInst = ret.map((r) => Math.abs(r));
+
+		// Per-candle components for OHLC-based estimators（lib/volatility.ts に委譲）
+		const pkSeries = parkinsonComponents(high, low);
+		const gkSeries = garmanKlassComponents(open, high, low, close);
+		const rsSeries = rogersSatchellComponents(open, high, low, close);
+
+		// True Range（lib/indicators.ts に委譲）
+		const trRaw = trueRange(high, low, close);
+		// trRaw[0] は NaN なので、互換性のため先頭を h-l で埋める
+		const trSeries = trRaw.map((v, i) => (Number.isFinite(v) ? v : Math.max(0, high[i] - low[i])));
+
+		// Aggregates over whole sample (use returns length for rv)
+		const rvStd = stddev(ret);
+		// Parkinson/GK/RS are per-candle estimators (not return-based), so use full series
+		const pkMean = pkSeries.reduce((s, v) => s + v, 0) / Math.max(1, pkSeries.length);
+		const gkMean = gkSeries.reduce((s, v) => s + v, 0) / Math.max(1, gkSeries.length);
+		const rsMean = rsSeries.reduce((s, v) => s + v, 0) / Math.max(1, rsSeries.length);
+		const parkinson = componentMeanToVol(pkMean, 'parkinson');
+		const garmanKlass = componentMeanToVol(gkMean, 'garmanKlass');
+		const rogersSatchell = componentMeanToVol(rsMean, 'rogersSatchell');
+
+		// ATR aggregate: use first window (default 14) SMA on TR, take last
+		const primaryWindow = Math.max(2, windows?.[0] || 14);
+		const atrSeries = slidingMean(trSeries, primaryWindow);
+		const atrAgg = atrSeries.length > 0 ? atrSeries[atrSeries.length - 1] : 0;
+
+		const annFactor = withAnn ? Math.sqrt(periodsPerYear(type)) : 1;
+		const rvStdAnn = withAnn ? rvStd * annFactor : undefined;
+
+		// Rolling per requested windows
+		const rollingOut: Array<{
+			window: number;
+			rv_std: number;
+			rv_std_ann?: number;
+			atr?: number;
+			parkinson?: number;
+			garmanKlass?: number;
+			rogersSatchell?: number;
+		}> = [];
+		for (const wRaw of windows) {
+			const w = Math.max(2, Math.min(wRaw | 0, ret.length));
+			if (w > ret.length) continue;
+			const rvStdRoll = slidingStddev(ret, w);
+			const rvStdLatest = rvStdRoll.at(-1) ?? 0;
+			const rvStdAnnLatest = withAnn ? rvStdLatest * annFactor : undefined;
+			const pkRoll = slidingMean(pkSeries, w);
+			const gkRoll = slidingMean(gkSeries, w);
+			const rsRoll = slidingMean(rsSeries, w);
+			const atrRoll = slidingMean(trSeries, w);
+			const p = pkRoll.length ? componentMeanToVol(pkRoll.at(-1) as number, 'parkinson') : undefined;
+			const gk = gkRoll.length ? componentMeanToVol(gkRoll.at(-1) as number, 'garmanKlass') : undefined;
+			const rs = rsRoll.length ? componentMeanToVol(rsRoll.at(-1) as number, 'rogersSatchell') : undefined;
+			const atr = atrRoll.length ? (atrRoll.at(-1) as number) : undefined;
+			rollingOut.push({
+				window: w,
+				rv_std: rvStdLatest,
+				rv_std_ann: rvStdAnnLatest,
+				atr,
+				parkinson: p,
+				garmanKlass: gk,
+				rogersSatchell: rs,
+			});
+		}
+
+		// Tags: always use annualized RV for consistent thresholds regardless of annualize flag
+		const tags: string[] = [];
+		const rvRefAnn = rvStdAnn ?? rvStd * Math.sqrt(periodsPerYear(type));
+		if (rvRefAnn >= 0.8) tags.push('volatile');
+		else if (rvRefAnn <= 0.3) tags.push('calm');
+
+		const data = {
+			meta: {
+				pair: chk.pair,
+				type: String(type),
+				fetchedAt: nowIso(),
+				baseIntervalMs: baseIntervalMsOf(type),
+				sampleSize: candles.length,
+				windows: [...windows],
+				annualize: withAnn,
+				useLogReturns: useLog,
+				source: 'bitbank:candlestick' as const,
+			},
+			aggregates: {
+				rv_std: Number(rvStd.toFixed(8)),
+				rv_std_ann: withAnn ? Number((rvStdAnn as number).toFixed(8)) : undefined,
+				parkinson: Number(parkinson.toFixed(8)),
+				garmanKlass: Number(garmanKlass.toFixed(8)),
+				rogersSatchell: Number(rogersSatchell.toFixed(8)),
+				atr: Number(atrAgg.toFixed(8)),
+			},
+			rolling: rollingOut.map((r) => ({
+				window: r.window,
+				rv_std: Number(r.rv_std.toFixed(8)),
+				rv_std_ann: r.rv_std_ann != null ? Number(r.rv_std_ann.toFixed(8)) : undefined,
+				atr: r.atr != null ? Number(r.atr.toFixed(8)) : undefined,
+				parkinson: r.parkinson != null ? Number(r.parkinson.toFixed(8)) : undefined,
+				garmanKlass: r.garmanKlass != null ? Number(r.garmanKlass.toFixed(8)) : undefined,
+				rogersSatchell: r.rogersSatchell != null ? Number(r.rogersSatchell.toFixed(8)) : undefined,
+			})),
+			series: {
+				ts,
+				close,
+				ret: ret.map((v) => Number(v.toFixed(8))),
+				rv_inst: rvInst.map((v) => Number(v.toFixed(8))),
+			},
+			tags,
+		};
+
+		const baseSummaryVol = formatSummary({
+			pair: chk.pair,
+			timeframe: String(type),
+			latest: close.at(-1),
+			extra: `rv=${(rvRefAnn).toFixed(3)}(ann)${tags.length ? ` ${tags.join(',')}` : ''}`,
+		});
+		// テキスト summary にボラティリティ詳細を含める（LLM が structuredContent.data を読めない対策）
+		const summary = buildVolatilityMetricsText({
+			baseSummary: baseSummaryVol,
+			aggregates: data.aggregates,
+			rolling: rollingOut,
+		});
+
+		const meta = createMeta(chk.pair, { type, count: candles.length });
+		return GetVolMetricsOutputSchema.parse(
+			ok<z.infer<typeof GetVolMetricsDataSchemaOut>, z.infer<typeof GetVolMetricsMetaSchemaOut>>(
+				summary,
+				data,
+				meta as z.infer<typeof GetVolMetricsMetaSchemaOut>,
+			),
+		);
+	} catch (e: unknown) {
+		return failFromError(e, { schema: GetVolMetricsOutputSchema });
+	}
+}

package/tools/patterns/aftermath.ts

@@ -0,0 +1,212 @@
+/**
+ * パターン事後分析 (aftermath)
+ *
+ * パターン完成後のブレイクアウト確認・理論目標価格・リターン計算を行う。
+ */
+
+import { avg as avgRaw, median as medianRaw } from '../../lib/math.js';
+import type { AftermathResult, CandleData, PatternEntry } from './types.js';
+
+// ---------------------------------------------------------------------------
+// ネックライン補間
+// ---------------------------------------------------------------------------
+export function necklineValue(p: PatternEntry, idx: number): number | null {
+	const nl = Array.isArray(p?.neckline) && p.neckline.length === 2 ? p.neckline : null;
+	if (!nl) return null;
+	const [a, b] = nl;
+	if (Number.isFinite(a?.x) && Number.isFinite(b?.x) && Number.isFinite(a?.y) && Number.isFinite(b?.y)) {
+		const x1 = Number(a.x),
+			y1 = Number(a.y),
+			x2 = Number(b.x),
+			y2 = Number(b.y);
+		if (x2 !== x1) {
+			const t = (idx - x1) / (x2 - x1);
+			return y1 + (y2 - y1) * Math.max(0, Math.min(1, t));
+		}
+		return y1;
+	}
+	return Number.isFinite(a?.y) ? Number(a.y) : Number.isFinite(b?.y) ? Number(b.y) : null;
+}
+
+// ---------------------------------------------------------------------------
+// 事後分析
+// ---------------------------------------------------------------------------
+const BULLISH_TYPES = [
+	'double_bottom',
+	'inverse_head_and_shoulders',
+	'triangle_ascending',
+	'triangle_symmetrical',
+	'flag',
+];
+const BEARISH_TYPES = ['double_top', 'head_and_shoulders', 'triangle_descending'];
+// Note: 'pennant' is intentionally excluded from both lists — its direction is determined by poleDirection field.
+
+export function analyzeAftermath(
+	p: PatternEntry,
+	candles: CandleData[],
+	isoToIndex: Map<string, number>,
+): AftermathResult | null {
+	try {
+		const endIso = p?.range?.end;
+		const endIdx = isoToIndex.has(String(endIso)) ? (isoToIndex.get(String(endIso)) as number) : -1;
+		if (endIdx < 0) return null;
+		const baseClose = Number(candles[endIdx]?.close ?? NaN);
+		if (!Number.isFinite(baseClose)) return null;
+		const nlAtEnd = necklineValue(p, endIdx);
+		const pType = String(p?.type);
+		const isPennant = pType === 'pennant';
+		const bullish = isPennant ? p?.poleDirection === 'up' : BULLISH_TYPES.includes(pType);
+		const bearish = isPennant ? p?.poleDirection === 'down' : BEARISH_TYPES.includes(pType);
+		if (!Number.isFinite(nlAtEnd as number)) return null;
+		let breakoutConfirmed = false;
+		let breakoutDate: string | undefined;
+		let daysToTarget: number | null = null;
+		const breakoutBuffer = 0.015;
+		for (let i = endIdx + 1; i < Math.min(candles.length, endIdx + 30); i++) {
+			const nl = necklineValue(p, i) ?? (nlAtEnd as number);
+			const c = Number(candles[i]?.close ?? NaN);
+			if (!Number.isFinite(c) || !Number.isFinite(nl)) continue;
+			if ((bullish && c > nl * (1 + breakoutBuffer)) || (bearish && c < nl * (1 - breakoutBuffer))) {
+				breakoutConfirmed = true;
+				breakoutDate = candles[i]?.isoTime;
+				break;
+			}
+		}
+		const horizon = [3, 7, 14];
+		const priceMove: Record<string, { return: number; high: number; low: number }> = {};
+		for (const h of horizon) {
+			const to = Math.min(candles.length - 1, endIdx + h);
+			if (to <= endIdx) continue;
+			let hi = -Infinity,
+				lo = Infinity;
+			for (let i = endIdx + 1; i <= to; i++) {
+				hi = Math.max(hi, Number(candles[i]?.high ?? -Infinity));
+				lo = Math.min(lo, Number(candles[i]?.low ?? Infinity));
+			}
+			const closeTo = Number(candles[to]?.close ?? NaN);
+			if (!Number.isFinite(closeTo)) continue;
+			const ret = ((closeTo - baseClose) / baseClose) * 100;
+			priceMove[`days${h}`] = {
+				return: Number(ret.toFixed(2)),
+				high: Number(hi.toFixed(0)),
+				low: Number(lo.toFixed(0)),
+			};
+		}
+		// theoretical target
+		let theoreticalTarget = NaN;
+		const nl = nlAtEnd as number;
+		const pivotPrices = Array.isArray(p?.pivots)
+			? p.pivots.map((x: { price?: number }) => Number(x?.price)).filter((x: number) => Number.isFinite(x))
+			: [];
+		if (bullish && pivotPrices.length) {
+			const patternLow = Math.min(...pivotPrices);
+			theoreticalTarget = nl + (nl - patternLow);
+		} else if (bearish && pivotPrices.length) {
+			const patternHigh = Math.max(...pivotPrices);
+			theoreticalTarget = nl - (patternHigh - nl);
+		}
+		let targetReached = false;
+		if (Number.isFinite(theoreticalTarget)) {
+			for (let i = endIdx + 1; i <= Math.min(candles.length - 1, endIdx + 14); i++) {
+				const hiVal = Number(candles[i]?.high ?? NaN);
+				const loVal = Number(candles[i]?.low ?? NaN);
+				if (bullish && Number.isFinite(hiVal) && hiVal >= theoreticalTarget) {
+					targetReached = true;
+					daysToTarget = i - endIdx;
+					break;
+				}
+				if (bearish && Number.isFinite(loVal) && loVal <= theoreticalTarget) {
+					targetReached = true;
+					daysToTarget = i - endIdx;
+					break;
+				}
+			}
+		}
+		// outcome message
+		function outcomeMessage(): string {
+			if (!breakoutConfirmed) return 'ネックライン未突破（パターン不発）';
+			if (targetReached) return '成功（理論目標価格到達）';
+			const r3 = priceMove?.days3?.return;
+			const r7 = priceMove?.days7?.return;
+			const r14 = priceMove?.days14?.return;
+			const arr = [r3, r7, r14].filter((v: unknown) => typeof v === 'number') as number[];
+			if (!arr.length) return '評価不可（事後データ不足）';
+			const best = arr.reduce((m, v) => (Math.abs(v) > Math.abs(m) ? v : m), 0);
+			const isBullish = isPennant ? p?.poleDirection === 'up' : BULLISH_TYPES.includes(String(p?.type));
+			const expected = isBullish ? 1 : -1;
+			const actual = best > 0 ? 1 : -1;
+			if (expected === actual && Math.abs(best) > 3)
+				return `部分成功（ブレイクアウト後${best > 0 ? '+' : ''}${best.toFixed(1)}%、目標未達）`;
+			if (expected !== actual && Math.abs(best) > 3)
+				return `失敗（ブレイクアウト後、期待と逆方向に${best > 0 ? '+' : ''}${best.toFixed(1)}%）`;
+			return `失敗（ブレイクアウト後、値動き僅少: ${best > 0 ? '+' : ''}${best.toFixed(1)}%）`;
+		}
+		const outcome = outcomeMessage();
+		return {
+			breakoutDate,
+			breakoutConfirmed,
+			priceMove,
+			targetReached,
+			theoreticalTarget: Number.isFinite(theoreticalTarget) ? Math.round(theoreticalTarget) : null,
+			outcome,
+			daysToTarget,
+		};
+	} catch {
+		return null;
+	}
+}
+
+// ---------------------------------------------------------------------------
+// 統計ビルド
+// ---------------------------------------------------------------------------
+export function buildStatistics(
+	patterns: PatternEntry[],
+	candles: CandleData[],
+): { statistics: Record<string, unknown>; isoToIndex: Map<string, number> } {
+	const isoToIndex = new Map<string, number>();
+	for (let i = 0; i < candles.length; i++) {
+		const t = candles[i]?.isoTime;
+		if (t) isoToIndex.set(String(t), i);
+	}
+	const stats: Record<
+		string,
+		{ detected: number; withAftermath: number; success: number; r7: number[]; r14: number[] }
+	> = {};
+	for (const p of patterns) {
+		const a = analyzeAftermath(p, candles, isoToIndex);
+		if (a) p.aftermath = a;
+		const t = String(p.type);
+		if (!stats[t]) stats[t] = { detected: 0, withAftermath: 0, success: 0, r7: [], r14: [] };
+		stats[t].detected += 1;
+		if (a) {
+			stats[t].withAftermath += 1;
+			if (a.outcome === 'success') stats[t].success += 1;
+			const r7 = a?.priceMove?.days7?.return;
+			if (typeof r7 === 'number') stats[t].r7.push(r7);
+			const r14 = a?.priceMove?.days14?.return;
+			if (typeof r14 === 'number') stats[t].r14.push(r14);
+		}
+	}
+
+	const avg = (arr: number[]) => {
+		const v = avgRaw(arr);
+		return v != null ? Number(v.toFixed(2)) : null;
+	};
+	const med = (arr: number[]) => {
+		const v = medianRaw(arr);
+		return v != null ? Number(v.toFixed(2)) : null;
+	};
+
+	const statistics: Record<string, unknown> = {};
+	for (const [k, v] of Object.entries(stats)) {
+		statistics[k] = {
+			detected: v.detected,
+			withAftermath: v.withAftermath,
+			successRate: v.withAftermath ? Number((v.success / v.withAftermath).toFixed(2)) : null,
+			avgReturn7d: avg(v.r7),
+			avgReturn14d: avg(v.r14),
+			medianReturn7d: med(v.r7),
+		};
+	}
+	return { statistics, isoToIndex };
+}

package/tools/patterns/config.ts

@@ -0,0 +1,151 @@
+/**
+ * patterns/config.ts - 時間軸に応じたパラメータ設定
+ *
+ * パターン検出で使用するデフォルトパラメータを時間軸ごとに提供する。
+ */
+
+/** パターンごとの最小整合度（閾値） */
+export const MIN_CONFIDENCE: Record<string, number> = {
+	triple_top: 0.7,
+	triple_bottom: 0.7,
+	double_top: 0.65,
+	double_bottom: 0.65,
+	head_and_shoulders: 0.7,
+	inverse_head_and_shoulders: 0.7,
+};
+
+/** スキーマのデフォルト値（サーバ側で埋められる値） */
+export const SCHEMA_DEFAULTS = {
+	swingDepth: 7,
+	minBarsBetweenSwings: 5,
+	tolerancePct: 0.04,
+} as const;
+
+/**
+ * 時間軸に応じたスイング検出パラメータを返す
+ */
+export function getDefaultParamsForTf(tf: string): { swingDepth: number; minBarsBetweenSwings: number } {
+	const t = String(tf);
+	// 期待動作（例）の目安に基づくデフォルト
+	if (t === '1hour') return { swingDepth: 3, minBarsBetweenSwings: 2 };
+	if (t === '4hour') return { swingDepth: 5, minBarsBetweenSwings: 3 };
+	if (t === '8hour') return { swingDepth: 5, minBarsBetweenSwings: 3 };
+	if (t === '12hour') return { swingDepth: 5, minBarsBetweenSwings: 3 };
+	if (t === '1day') return { swingDepth: 6, minBarsBetweenSwings: 4 };
+	if (t === '1week') return { swingDepth: 7, minBarsBetweenSwings: 5 };
+	if (t === '1month') return { swingDepth: 8, minBarsBetweenSwings: 6 };
+	// 分足はやや緩め（ノイズ多めのため最小幅は確保）
+	if (t === '30min') return { swingDepth: 3, minBarsBetweenSwings: 2 };
+	if (t === '15min') return { swingDepth: 3, minBarsBetweenSwings: 2 };
+	if (t === '5min') return { swingDepth: 2, minBarsBetweenSwings: 1 };
+	if (t === '1min') return { swingDepth: 2, minBarsBetweenSwings: 1 };
+	// フォールバック（日足相当）
+	return { swingDepth: 6, minBarsBetweenSwings: 4 };
+}
+
+/**
+ * 時間軸に応じた許容誤差（tolerancePct）を返す
+ */
+export function getDefaultToleranceForTf(tf: string): number {
+	const t = String(tf);
+	if (t === '1hour' || t === '4hour') return 0.05; // 5%
+	if (t === '8hour' || t === '12hour') return 0.045; // 4.5%
+	if (t === '15min' || t === '30min') return 0.06; // 6%
+	if (t === '1week') return 0.035; // 3.5%
+	if (t === '1month') return 0.03; // 3.0%
+	return 0.04; // 1day 他
+}
+
+/**
+ * 時間軸に応じた収束係数を返す（三角形・ウェッジ用）
+ */
+export function getConvergenceFactorForTf(tf: string): number {
+	const t = String(tf);
+	if (t === '1hour' || t === '4hour' || t === '15min' || t === '30min') return 0.6;
+	return 0.8; // default
+}
+
+/**
+ * 時間軸に応じた三角形の係数を返す
+ */
+export function getTriangleCoeffForTf(tf: string): { flat: number; move: number } {
+	const t = String(tf);
+	if (t === '1hour' || t === '4hour') return { flat: 1.2, move: 0.8 };
+	return { flat: 0.8, move: 1.2 };
+}
+
+/**
+ * 時間軸に応じた最小フィット値を返す
+ */
+export function getMinFitForTf(tf: string): number {
+	const t = String(tf);
+	if (t === '1hour' || t === '4hour') return 0.6;
+	if (t === '1day') return 0.7;
+	return 0.75;
+}
+
+/**
+ * 時間軸に応じた三角形のウィンドウサイズを返す
+ */
+export function getTriangleWindowSize(tf: string): number {
+	const t = String(tf);
+	// 長期: 大きなパターン
+	if (t === '1month') return 30;
+	if (t === '1week') return 40;
+	// 中期
+	if (t === '1day') return 50;
+	// 短期
+	if (t === '4hour') return 30;
+	if (t === '1hour') return 40;
+	if (t === '30min') return 30;
+	if (t === '15min') return 30;
+	return 20;
+}
+
+/**
+ * オプションとスキーマデフォルトから実効パラメータを解決する
+ */
+export function resolveParams(
+	tf: string,
+	opts: Partial<{
+		swingDepth: number;
+		tolerancePct: number;
+		minBarsBetweenSwings: number;
+	}>,
+): {
+	swingDepth: number;
+	tolerancePct: number;
+	minBarsBetweenSwings: number;
+	autoScaled: boolean;
+} {
+	const auto = getDefaultParamsForTf(tf);
+	const tolAuto = getDefaultToleranceForTf(tf);
+
+	// swingDepth: スキーマ既定値(7)が来た場合は時間軸オートに置換
+	const swingDepth = Number.isFinite(opts.swingDepth as number)
+		? (opts.swingDepth as number) === SCHEMA_DEFAULTS.swingDepth
+			? auto.swingDepth
+			: (opts.swingDepth as number)
+		: auto.swingDepth;
+
+	// tolerancePct: スキーマ既定値(0.04)が来た場合は時間軸オートを採用
+	const tolerancePct =
+		typeof opts.tolerancePct === 'number' && !Number.isNaN(opts.tolerancePct)
+			? (opts.tolerancePct as number) === SCHEMA_DEFAULTS.tolerancePct
+				? tolAuto
+				: (opts.tolerancePct as number)
+			: tolAuto;
+
+	// minBarsBetweenSwings: 同様に既定値(5)なら時間軸オートに置換
+	const minBarsBetweenSwings = Number.isFinite(opts.minBarsBetweenSwings as number)
+		? (opts.minBarsBetweenSwings as number) === SCHEMA_DEFAULTS.minBarsBetweenSwings
+			? auto.minBarsBetweenSwings
+			: (opts.minBarsBetweenSwings as number)
+		: auto.minBarsBetweenSwings;
+
+	const autoScaled = !(
+		Number.isFinite(opts.swingDepth as number) || Number.isFinite(opts.minBarsBetweenSwings as number)
+	);
+
+	return { swingDepth, tolerancePct, minBarsBetweenSwings, autoScaled };
+}