@nomadamas/k-skill 0.9.1 → 0.10.0

package/skills/market-event-impact/scripts/research.py

@@ -0,0 +1,389 @@
+#!/usr/bin/env python3
+"""Validate reproducible narrative research inputs for arbitrary market events."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import date, datetime, time as dt_time
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlparse
+
+from calendars import valid_timezone
+from event_resolver import EVENT_TYPES, infer_event_type, stable_event_id
+
+
+class ResearchError(ValueError):
+    pass
+
+
+def _source(value: Any, context: str) -> dict[str, str]:
+    if not isinstance(value, dict) or not str(value.get("name") or "").strip() or not str(value.get("url") or "").strip():
+        raise ResearchError(f"{context} needs source.name and source.url")
+    url = str(value["url"]).strip()
+    parsed = urlparse(url)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise ResearchError(f"{context}.source.url must be an http(s) URL")
+    return {"name": str(value["name"]).strip(), "url": url}
+
+
+def _text(value: Any, context: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ResearchError(f"{context} must be a non-empty string")
+    return value.strip()
+
+
+def _claim_list(value: Any, field: str) -> list[dict[str, Any]]:
+    if value is None:
+        return []
+    if not isinstance(value, list) or not all(isinstance(item, dict) for item in value):
+        raise ResearchError(f"{field} must be an object array")
+    result = []
+    for index, item in enumerate(value):
+        context = f"{field}[{index}]"
+        result.append({
+            "channel": _text(item.get("channel"), f"{context}.channel"),
+            "finding": _text(item.get("finding"), f"{context}.finding"),
+            "significance": _text(item.get("significance"), f"{context}.significance"),
+            "source": _source(item.get("source"), context),
+        })
+    return result
+
+
+def _catalysts(value: Any) -> list[dict[str, Any]]:
+    if value is None:
+        return []
+    if not isinstance(value, list) or not all(isinstance(item, dict) for item in value):
+        raise ResearchError("catalysts must be an object array")
+    result = []
+    for index, item in enumerate(value):
+        context = f"catalysts[{index}]"
+        try:
+            event_date = date.fromisoformat(str(item.get("date"))).isoformat()
+        except ValueError as exc:
+            raise ResearchError(f"{context}.date must be YYYY-MM-DD") from exc
+        time_local = item.get("time_local")
+        timezone_name = item.get("timezone")
+        if bool(time_local) != bool(timezone_name):
+            raise ResearchError(f"{context}.time_local and timezone must be provided together")
+        if time_local:
+            try:
+                parsed_time = dt_time.fromisoformat(str(time_local))
+                if parsed_time.tzinfo is not None or not valid_timezone(str(timezone_name), date.fromisoformat(event_date)):
+                    raise ValueError
+            except ValueError as exc:
+                raise ResearchError(f"{context}.time_local requires local time and valid IANA timezone") from exc
+            time_local = parsed_time.isoformat(timespec="minutes" if parsed_time.second == 0 else "seconds")
+        result.append({
+            "date": event_date,
+            "time_local": time_local,
+            "timezone": timezone_name,
+            "event": _text(item.get("event"), f"{context}.event"),
+            "why_it_matters": _text(item.get("why_it_matters"), f"{context}.why_it_matters"),
+            "source": _source(item.get("source"), context),
+        })
+    result.sort(key=lambda item: (item["date"], item["time_local"] or ""))
+    return result
+
+
+def _transmission(value: Any) -> list[dict[str, Any]]:
+    if value is None:
+        return []
+    if not isinstance(value, list) or not all(isinstance(item, dict) for item in value):
+        raise ResearchError("transmission must be an object array")
+    allowed = {"CONFIRMED", "CONSISTENT", "MIXED", "CONTRADICTED", "UNVERIFIED"}
+    result = []
+    for index, item in enumerate(value):
+        context = f"transmission[{index}]"
+        raw_status = str(item.get("status", "")).strip().casefold()
+        status = {"confirmed": "CONFIRMED", "consistent": "CONSISTENT", "limited": "MIXED", "mixed": "MIXED", "contradicted": "CONTRADICTED", "unverified": "UNVERIFIED"}.get(raw_status, "")
+        if status not in allowed:
+            raise ResearchError(f"{context}.status must be one of {sorted(allowed)}")
+        origin = _text(item.get("from"), f"{context}.from")
+        destination = _text(item.get("to"), f"{context}.to")
+        if origin.casefold() == destination.casefold():
+            raise ResearchError(f"{context}.from and .to must differ")
+        result.append({
+            "from": origin,
+            "to": destination,
+            "status": status,
+            "evidence": _text(item.get("evidence"), f"{context}.evidence"),
+            "source": _source(item.get("source"), context),
+        })
+    keys = [(item["from"].casefold(), item["to"].casefold()) for item in result]
+    if len(keys) != len(set(keys)):
+        raise ResearchError("transmission contains duplicate steps")
+    return result
+
+
+def _history(value: Any) -> dict[str, Any]:
+    if value is None:
+        return {"include": False, "reason": None, "comparisons": []}
+    if not isinstance(value, dict):
+        raise ResearchError("historical_context must be an object")
+    include_raw = value.get("include", False)
+    if not isinstance(include_raw, bool):
+        raise ResearchError("historical_context.include must be true or false")
+    include = include_raw
+    comparisons = value.get("comparisons", [])
+    if not isinstance(comparisons, list) or not all(isinstance(item, dict) for item in comparisons):
+        raise ResearchError("historical_context.comparisons must be an object array")
+    normalized = []
+    for index, item in enumerate(comparisons):
+        context = f"historical_context.comparisons[{index}]"
+        try:
+            event_date = date.fromisoformat(str(item.get("date"))).isoformat()
+        except ValueError as exc:
+            raise ResearchError(f"{context}.date must be YYYY-MM-DD") from exc
+        normalized.append({
+            "date": event_date,
+            "event": _text(item.get("event"), f"{context}.event"),
+            "matching_basis": _text(item.get("matching_basis") or item.get("similarity"), f"{context}.matching_basis"),
+            "similarity": _text(item.get("similarity"), f"{context}.similarity"),
+            "difference": _text(item.get("difference"), f"{context}.difference"),
+            "source": _source(item.get("source"), context),
+        })
+    if include and not 3 <= len(normalized) <= 5:
+        raise ResearchError("historical_context.include=true needs 3 to 5 comparisons")
+    if not include and normalized:
+        raise ResearchError("historical_context comparisons require include=true")
+    return {
+        "include": include,
+        "reason": _text(value.get("reason"), "historical_context.reason") if include else None,
+        "comparisons": sorted(normalized, key=lambda item: item["date"]),
+    }
+
+
+def _tokens(value: Any, context: str) -> list[str]:
+    if not isinstance(value, list) or not all(isinstance(item, str) and item.strip() for item in value):
+        raise ResearchError(f"{context} must be a non-empty-string array")
+    return list(dict.fromkeys(item.strip().casefold() for item in value))
+
+
+def _shock_pattern(value: Any, context: str) -> dict[str, str]:
+    allowed = {"up", "down", "mixed", "flat", "wider", "tighter"}
+    if not isinstance(value, dict) or not value:
+        raise ResearchError(f"{context} must be a non-empty object")
+    result = {}
+    for raw_key, raw_direction in value.items():
+        key = _text(raw_key, f"{context} key").casefold()
+        direction = _text(raw_direction, f"{context}.{key}").casefold()
+        if direction not in allowed:
+            raise ResearchError(f"{context}.{key} must be one of {sorted(allowed)}")
+        result[key] = direction
+    return result
+
+
+def _event_features(value: Any, context: str = "event_features") -> dict[str, Any]:
+    if value is None:
+        return {"shock_mechanisms": [], "affected_channels": [], "market_shock_pattern": {}}
+    if not isinstance(value, dict):
+        raise ResearchError(f"{context} must be an object")
+    mechanisms = _tokens(value.get("shock_mechanisms", []), f"{context}.shock_mechanisms") if value.get("shock_mechanisms") else []
+    channels = _tokens(value.get("affected_channels", []), f"{context}.affected_channels") if value.get("affected_channels") else []
+    pattern = _shock_pattern(value["market_shock_pattern"], f"{context}.market_shock_pattern") if value.get("market_shock_pattern") else {}
+    return {"shock_mechanisms": mechanisms, "affected_channels": channels, "market_shock_pattern": pattern}
+
+
+def _analogue_pool(value: Any, event_date: str) -> list[dict[str, Any]]:
+    if value is None:
+        return []
+    if not isinstance(value, list) or not all(isinstance(item, dict) for item in value):
+        raise ResearchError("historical_analogue_pool must be an object array")
+    if len(value) > 50:
+        raise ResearchError("historical_analogue_pool supports at most 50 candidates")
+    result = []
+    keys = set()
+    for index, item in enumerate(value):
+        context = f"historical_analogue_pool[{index}]"
+        try:
+            candidate_date = date.fromisoformat(str(item.get("date"))).isoformat()
+        except ValueError as exc:
+            raise ResearchError(f"{context}.date must be YYYY-MM-DD") from exc
+        if candidate_date >= event_date:
+            raise ResearchError(f"{context}.date must be before the research event_date")
+        event_type = _text(item.get("event_type"), f"{context}.event_type").casefold().replace(" ", "_")
+        if event_type not in EVENT_TYPES:
+            raise ResearchError(f"{context}.event_type is unsupported")
+        features = _event_features(item, context)
+        if not features["shock_mechanisms"] or not features["affected_channels"] or not features["market_shock_pattern"]:
+            raise ResearchError(f"{context} needs shock_mechanisms, affected_channels, and market_shock_pattern")
+        candidate = {
+            "date": candidate_date,
+            "event": _text(item.get("event"), f"{context}.event"),
+            "event_type": event_type,
+            **features,
+            "similarity": _text(item.get("similarity"), f"{context}.similarity"),
+            "difference": _text(item.get("difference"), f"{context}.difference"),
+            "source": _source(item.get("source"), context),
+        }
+        key = (candidate_date, candidate["event"].casefold())
+        if key in keys:
+            raise ResearchError("historical_analogue_pool contains duplicate events")
+        keys.add(key)
+        result.append(candidate)
+    return result
+
+
+def _overlap(left: set[str], right: set[str]) -> float:
+    union = left | right
+    return len(left & right) / len(union) if union else 0.0
+
+
+def _rank_analogues(current: dict[str, Any], candidates: list[dict[str, Any]], event_type: str) -> dict[str, Any]:
+    ranked = []
+    for candidate in candidates:
+        mechanism_overlap = _overlap(set(current["shock_mechanisms"]), set(candidate["shock_mechanisms"]))
+        channel_overlap = _overlap(set(current["affected_channels"]), set(candidate["affected_channels"]))
+        current_pattern = current["market_shock_pattern"]
+        candidate_pattern = candidate["market_shock_pattern"]
+        shared_keys = set(current_pattern) & set(candidate_pattern)
+        pattern_union = set(current_pattern) | set(candidate_pattern)
+        pattern_overlap = (
+            sum(current_pattern[key] == candidate_pattern[key] for key in shared_keys) / len(pattern_union)
+            if pattern_union else 0.0
+        )
+        if mechanism_overlap == 0 or pattern_overlap == 0:
+            continue
+        type_match = event_type == candidate["event_type"]
+        score = round(2.0 * type_match + 3.0 * mechanism_overlap + 2.0 * channel_overlap + 4.0 * pattern_overlap, 6)
+        matching_basis = (
+            f"사건유형 {'일치' if type_match else '불일치'}, 충격 메커니즘 중복률 {mechanism_overlap:.0%}, "
+            f"영향 채널 중복률 {channel_overlap:.0%}, 관측된 시장충격 방향 일치율 {pattern_overlap:.0%}"
+        )
+        ranked.append((score, candidate["date"], candidate, matching_basis))
+    ranked.sort(key=lambda item: (-item[0], item[1], item[2]["event"].casefold()))
+    if len(ranked) < 3:
+        return {
+            "include": False,
+            "reason": "특성과 시장충격 방향을 함께 대조할 검증된 과거 후보가 3개 미만입니다.",
+            "comparisons": [],
+        }
+    comparisons = []
+    for score, _, candidate, matching_basis in ranked[:5]:
+        comparisons.append({
+            "date": candidate["date"],
+            "event": candidate["event"],
+            "matching_basis": matching_basis,
+            "similarity": candidate["similarity"],
+            "difference": candidate["difference"],
+            "score": score,
+            "source": candidate["source"],
+        })
+    return {
+        "include": True,
+        "reason": "사건 특성과 실제 시장충격 방향을 함께 점수화해 과거 사례를 정렬했습니다.",
+        "comparisons": comparisons,
+    }
+
+
+def normalize_research(item: dict[str, Any]) -> dict[str, Any]:
+    try:
+        event_date = date.fromisoformat(str(item.get("event_date"))).isoformat()
+    except ValueError as exc:
+        raise ResearchError("research event_date must be YYYY-MM-DD") from exc
+    region = str(item.get("region", "")).upper()
+    if not re.fullmatch(r"[A-Z]{2,6}", region):
+        raise ResearchError("research region must be a 2-6 letter market code")
+    overview = item.get("overview") or item.get("decision")
+    if not isinstance(overview, dict):
+        raise ResearchError("research overview must be an object")
+    if overview.get("expected") is not None and not isinstance(overview.get("expected"), bool):
+        raise ResearchError("overview.expected must be true, false, or null")
+    event_name = _text(item.get("event_name") or item.get("event_family"), "research.event_name")
+    event_id = str(item.get("event_id") or "").strip().casefold() or stable_event_id(event_name)
+    if not re.fullmatch(r"[a-z0-9][a-z0-9._-]{0,95}", event_id):
+        raise ResearchError("research.event_id must use 1-96 lowercase letters, numbers, dots, underscores, or hyphens")
+    raw_event_type = item.get("event_type")
+    event_type = (_text(raw_event_type, "research.event_type").casefold().replace(" ", "_")
+                  if raw_event_type is not None else infer_event_type(f"{event_name} {item.get('event_family') or ''}")[0])
+    if not event_id:
+        raise ResearchError("research.event_id is required when it cannot be derived from event_name")
+    if event_type not in EVENT_TYPES:
+        raise ResearchError(f"unsupported research event_type: {event_type}")
+    research_observed_at = item.get("observed_at")
+    if research_observed_at is not None:
+        try:
+            parsed_research_observed_at = datetime.fromisoformat(str(research_observed_at).replace("Z", "+00:00"))
+        except ValueError as exc:
+            raise ResearchError("research observed_at must be ISO 8601 with a timezone") from exc
+        if parsed_research_observed_at.tzinfo is None:
+            raise ResearchError("research observed_at must be ISO 8601 with a timezone")
+        research_observed_at = parsed_research_observed_at.isoformat()
+    normalized = {
+        "region": region,
+        "event_id": event_id,
+        "event_name": event_name,
+        "event_family": str(item.get("event_family") or "").strip().upper().replace(" ", "_") or None,
+        "event_type": event_type,
+        "event_date": event_date,
+        "observed_at": research_observed_at,
+        "event_features": _event_features(item.get("event_features")),
+        "historical_analogue_pool": _analogue_pool(item.get("historical_analogue_pool"), event_date),
+        "overview": {
+            "summary": _text(overview.get("summary"), "overview.summary"),
+            "expected": overview.get("expected") if isinstance(overview.get("expected"), bool) else None,
+            "surprise_assessment": _text(overview.get("surprise_assessment"), "overview.surprise_assessment"),
+            "classification": _text(overview.get("classification") or overview.get("event_type"), "overview.classification"),
+            "source": _source(overview.get("source"), "overview"),
+        },
+        "what_changed": _claim_list(item.get("what_changed"), "what_changed"),
+        "adapter_details": _claim_list(item.get("adapter_details"), "adapter_details"),
+        "market_interpretation": _claim_list(item.get("market_interpretation"), "market_interpretation"),
+        "transmission": _transmission(item.get("transmission")),
+        "catalysts": _catalysts(item.get("catalysts")),
+        "historical_context": _history(item.get("historical_context")),
+    }
+    if not normalized["historical_context"]["include"] and normalized["historical_analogue_pool"]:
+        normalized["historical_context"] = _rank_analogues(
+            normalized["event_features"], normalized["historical_analogue_pool"], event_type
+        )
+    if not normalized["what_changed"]:
+        raise ResearchError("research needs at least one what_changed claim")
+    if not normalized["market_interpretation"]:
+        raise ResearchError("research needs at least one market_interpretation claim")
+    if not normalized["transmission"]:
+        raise ResearchError("research needs at least one transmission step; use unverified when evidence is unavailable")
+    if len(normalized["catalysts"]) < 2:
+        raise ResearchError("research needs at least two relevant catalysts")
+    if len(normalized["catalysts"]) > 8:
+        raise ResearchError("research supports at most eight relevant catalysts")
+    catalyst_keys = [(item["date"], item["event"].casefold()) for item in normalized["catalysts"]]
+    if len(catalyst_keys) != len(set(catalyst_keys)):
+        raise ResearchError("research contains duplicate catalysts")
+    if any(item["date"] <= event_date for item in normalized["catalysts"]):
+        raise ResearchError("catalysts must be after the research event_date")
+    history = normalized["historical_context"]
+    if any(item["date"] >= event_date for item in history["comparisons"]):
+        raise ResearchError("historical comparisons must be before the research event_date")
+    return normalized
+
+
+def load_research_file(path_text: str) -> list[dict[str, Any]]:
+    path = Path(path_text).expanduser()
+    if not path.is_file():
+        raise ResearchError(f"research file not found: {path}")
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8-sig"))
+    except json.JSONDecodeError as exc:
+        raise ResearchError(f"invalid research JSON: {exc}") from exc
+    items = payload.get("research") if isinstance(payload, dict) else payload
+    if not isinstance(items, list) or not all(isinstance(item, dict) for item in items):
+        raise ResearchError("research file must be an array or contain a research array")
+    normalized = [normalize_research(item) for item in items]
+    keys = [(item["event_id"], item["event_date"]) for item in normalized]
+    if len(keys) != len(set(keys)):
+        raise ResearchError("research file contains duplicate event keys")
+    return normalized
+
+
+def select_research(items: list[dict[str, Any]], event: dict[str, Any]) -> dict[str, Any]:
+    matches = [item for item in items if item["event_id"] == event["event_id"] and item["event_date"] == event["event_date"]]
+    if not matches:
+        matches = [item for item in items if item["event_name"].casefold() == event["event_name"].casefold() and item["event_date"] == event["event_date"]]
+    if not matches and event.get("event_family"):
+        matches = [item for item in items if item.get("event_family") == event.get("event_family") and item["region"] == event["region"] and item["event_date"] == event["event_date"]]
+    if len(matches) != 1:
+        raise ResearchError(f"research file must contain exactly one matching event; found {len(matches)}")
+    return matches[0]

package/skills/market-event-impact/skill.json

@@ -0,0 +1,9 @@
+{
+  "name": "market-event-impact",
+  "description": "GS Quant의 event_study·event_impact_analysis·CalendarAlignment 구조에서 영감을 받아, 정례 발표와 비정형 사건의 핵심 변화 및 시장 해석을 공식자료·당시 보도·검증 가격으로 정리한다. 교차자산 전달경로를 살피고 이벤트 스터디는 보조 증거로 제시하며, 유사사례와 다음 촉매를 한국어로 설명한다. Use for named market-moving events. Not for live quotes, forecasts, or investment advice.",
+  "profiles": [
+    "lookup",
+    "browser"
+  ],
+  "frontmatter": "name: market-event-impact\ndescription: GS Quant의 event_study·event_impact_analysis·CalendarAlignment 구조에서 영감을 받아, 정례 발표와 비정형 사건의 핵심 변화 및 시장 해석을 공식자료·당시 보도·검증 가격으로 정리한다. 교차자산 전달경로를 살피고 이벤트 스터디는 보조 증거로 제시하며, 유사사례와 다음 촉매를 한국어로 설명한다. Use for named market-moving events. Not for live quotes, forecasts, or investment advice.\nlicense: MIT\nmetadata:\n  category: finance\n  locale: ko-KR\n  phase: v1"
+}

package/skills/multi-asset-morning-briefing/instruction.md

@@ -0,0 +1,117 @@
+# 멀티에셋 모닝 브리핑
+
+## What this skill does
+
+서울 기준 아침에 끝난 가장 최근 미국·한국 세션을 각각 확인하고, 글로벌 자산의 움직임과 한국시장 전달 경로를 근거 링크가 있는 한국어 리서치 메모로 작성한다. 조회·작성 전용이며 실시간 호가, 매매 신호, 투자 권유는 제공하지 않는다.
+
+## When to use
+
+- 모닝 브리핑, Morning Call, 오버나이트 시황, 데일리 마켓 브리핑 작성
+- 기존 브리핑의 숫자·세션·출처·인과관계 검수
+
+## Workflow
+
+### 1. 기준일과 세션
+
+`briefing-date`는 서울 기준 브리핑 날짜다. 미국 오버나잇과 한국 전일은 같은 달력 날짜라고 가정하지 않는다.
+
+```bash
+npx -y @nomadamas/k-skill@0 exec multi-asset-morning-briefing scripts/market_data.py -- snapshot --briefing-date 2026-09-17
+```
+
+`sessions.us_overnight`는 Cboe VIX 관측일, `sessions.korea_previous`는 ECOS KOSPI 관측일로 독립 확인한다. 한 원천이 실패하면 다른 시장의 결과는 유지하고 해당 세션만 `null`로 둔다. 브리핑 시점 이후 관측값, 장중 값, 다음 거래일 값은 사용하지 않는다.
+
+개별 공식 원천을 다시 확인할 때:
+
+```bash
+npx -y @nomadamas/k-skill@0 exec multi-asset-morning-briefing scripts/market_data.py -- yields --last 5 --session 2026-09-16
+npx -y @nomadamas/k-skill@0 exec multi-asset-morning-briefing scripts/market_data.py -- cboe-vix --last 5 --session 2026-09-16
+npx -y @nomadamas/k-skill@0 exec multi-asset-morning-briefing scripts/market_data.py -- ecb-fx --last 5 --session 2026-09-16
+```
+
+helper의 `observed`, `session`, `basis`, `unit`, `stale`, `warnings`, `failures`를 확인한다. `stale: true`인 값은 목표 세션 값으로 쓰지 않는다.
+
+### 2. 공식 원천 우선 조사
+
+helper는 전체 브리핑이 아니라 검증 가능한 기초 사실 집합이다. browser/web 조사로 다음을 보강한다.
+
+1. 중앙은행·통계기관·재무부·거래소·기업 IR/공시
+2. 지수·선물·원자재 거래소 또는 신뢰할 수 있는 시세 제공처
+3. Reuters, Bloomberg, CNBC, 연합인포맥스, 연합뉴스 등 원문 기사
+
+최소 확인 범위:
+
+- S&P 500, Nasdaq, Dow, Russell 2000, SOX, VIX와 주요 업종
+- 미국 국채 2Y·10Y·30Y, 2s10s, 핵심 거시지표 실제·예상·이전치
+- DXY, USD/JPY, EUR/USD, GBP/USD, USD/KRW 현물 또는 NDF
+- WTI·Brent(`USD/bbl`), 금(`USD/oz`), 구리(`USD/lb` 또는 `USD/metric ton`)
+- 지수 기여도가 크거나 촉매가 확인된 개별 종목
+- KOSPI·KOSDAQ, 국내 3Y·10Y, EWY·야간선물·ADR 등 한국 선행 신호
+
+가격은 `종목/계약월 · 세션 · 종가/정산가/장중 · 값 · 등락률`을 한 묶음으로 확인한다. 숫자나 방향의 차이를 세션·계약월·단위로 설명하지 못하면 제외한다.
+
+### 3. 뉴스와 기준시각
+
+브리핑 날짜의 `07:00 KST`를 기본 cutoff로 사용하되 사용자가 다른 작성 시각을 주면 그 시각을 따른다. 발행시각이 cutoff 이후인 기사와 장 마감 뒤 기사는 해당 브리핑 근거에서 제외한다.
+
+제목 부분 문자열만으로 섹션을 분류하지 않는다. 기사 원문을 열어 대상 자산과 촉매를 확인한다. 예를 들어 `공원화`는 원화 기사로, 단순 달러 금액은 FX 기사로 분류하지 않는다.
+
+### 4. 향후 5거래일 일정
+
+Investing.com HTML 자동 파싱을 사용하지 않는다. 브리핑일부터 시작하는 **한국 거래일 5개**를 먼저 계산하고, Fed·BLS·BEA·U.S. Treasury·ECB·BOJ·한국은행·통계청·기업 IR 등 공식 일정에서 날짜와 시간을 확인한다. 공식 일정이 불명확할 때만 신뢰 가능한 경제 캘린더로 교차 확인한다.
+
+각 일정에는 날짜, KST 시간(확인 가능할 때), 이벤트, 예상/이전치(확보 시), 시장이 주목할 이유를 적고 공식 일정 링크를 붙인다.
+
+### 5. 분석과 출처
+
+- 사실·수치: 원천 수치와 기준시점이 확인된 경우만 사용
+- 원인: 기사나 공식 발언이 직접 설명했거나 뉴스와 가격 반응이 함께 뒷받침할 때만 단정
+- 전망: `~할 경우`, `확인할 변수`, `부담 요인`처럼 조건부로 표시
+- 한국시장: 업종·스타일·외국인 수급·환율·금리 경로와 반대 위험을 함께 제시
+
+모든 사실·수치·해석 bullet 끝에 직접 근거가 되는 Markdown 링크를 하나 이상 붙인다. 검색 결과 제목이나 스니펫은 출처로 쓰지 않는다.
+
+세부 산술·단위·문체 검수 규칙은 필요할 때 읽는다.
+
+```bash
+npx -y @nomadamas/k-skill@0 read multi-asset-morning-briefing references/format-rules.md
+```
+
+## Output contract
+
+파일을 만들지 않고 대화에만 출력한다. 첫 줄과 7개 섹션 이름은 정확히 다음과 같다.
+
+```text
+YYYY.MM.DD Morning Market Briefing
+
+1. Summary
+2. Rates
+3. FX
+4. Commodity
+5. Equity, Vol
+6. 한국 증시
+7. 주요 일정
+```
+
+- 각 항목은 `•`로 시작하고 핵심 수치/주장과 의미를 한 문장 안에서 연결한다.
+- 문장 끝은 `상승`, `하락`, `확대`, `축소`, `부담`, `긍정적`, `핵심`, `변수`, `확인 필요` 같은 리서치 메모형으로 맞춘다.
+- 작성자 이름과 `by` 표기를 넣지 않는다.
+- 항목을 못 구했으면 그 항목만 `확보하지 못함`으로 표시한다. 근거가 전혀 없는 섹션만 `확보 실패`로 표시한다.
+
+## Done when
+
+- 미국·한국 세션이 독립적으로 확인됨
+- 7개 섹션과 향후 5개 한국 거래일 일정이 모두 존재함
+- 핵심 자산의 값·단위·세션·가격 기준이 명시됨
+- 모든 사실·수치·해석에 직접 근거 링크가 있음
+- 확인되지 않은 값, cutoff 이후 기사, 서술형 종결, 작성자 표기가 없음
+
+## Failure modes
+
+| 상황 | 동작 |
+| --- | --- |
+| 한 원천의 HTTP·파싱 실패 | `failures[]`에 격리하고 다른 원천·섹션 계속 진행 |
+| `stale: true` 또는 세션 불일치 | 대체 원천 확인, 해결되지 않으면 값 제외 |
+| 공식 일정 접근 실패 | 다른 공식 기관 일정 → 신뢰 가능한 캘린더 순으로 교차 확인 |
+| 출처 간 값 불일치 | 세션·계약월·단위·종가/정산가를 대조; 해결되지 않으면 제외 |
+| 핵심 근거 전체 실패 | 기억이나 추정으로 채우지 않고 확보 실패를 명시 |