@routinecrew/routinecode 2.31.44 → 2.31.46

package/hooks/lib/known_solution.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+"""[KNOWN-SOLUTION] 주입 공유 모듈 — error-fix 지식(events.jsonl)의 결정적 소비 경로.
+
+설계: .routinecode/plans/design-knowledge-consumption-loop.md (design score 96)
+사용처: user-prompt-submit.sh(L1, additionalContext) / post-bash-knowledge.sh(L2, systemMessage)
+
+원칙: 보수 이중 문턱(12자+ 공통 부분열 OR 토큰 자카드>=0.5), 1건만, 저장된 지식 필드만 인용
+(사용자 프롬프트 원문 비포함), 세션x시그니처 1회(dedup 마커), 실패 시 조용히 None(fail-open).
+"""
+import hashlib
+import json
+import os
+import re
+import time
+
+KN_DIR = os.path.expanduser('~/.routinecode/knowledge')
+EVENTS = os.path.join(KN_DIR, 'events.jsonl')
+MAX_ROWS = 5000
+
+ERROR_HINT = re.compile(
+    r'(Error|에러|실패|Exception|Cannot |undefined|TypeError|Traceback|ERR_|error:)', re.I)
+
+
+def _normalize(s):
+    s = str(s or '').lower()
+    s = re.sub(r'/[\w./\-]{8,}', '*', s)        # 절대경로 → *
+    s = re.sub(r'\d+', '#', s)                   # 숫자 → #
+    s = re.sub(r'\s+', ' ', s).strip()
+    return s
+
+
+def _tokens(s):
+    return set(re.findall(r'[a-z가-힣_]{3,}', s))
+
+
+def _jaccard(a, b):
+    if not a or not b:
+        return 0.0
+    return len(a & b) / len(a | b)
+
+
+def _common_substr_len(a, b):
+    """최장 공통 부분열 길이 (O(n*m) — 시그니처 400자 캡이라 충분히 빠름)."""
+    a, b = a[:400], b[:400]
+    if not a or not b:
+        return 0
+    prev = [0] * (len(b) + 1)
+    best = 0
+    for i in range(1, len(a) + 1):
+        cur = [0] * (len(b) + 1)
+        for j in range(1, len(b) + 1):
+            if a[i - 1] == b[j - 1]:
+                cur[j] = prev[j - 1] + 1
+                if cur[j] > best:
+                    best = cur[j]
+        prev = cur
+    return best
+
+
+def _tenant_ok(entry_tid):
+    """pre-read-inject _tenant_ok와 동일 의미(무태그=통과). 현 events.jsonl 전행 무태그 — 미래 대비."""
+    legacy = entry_tid in (None, 0, '0', '')
+    if legacy:
+        return True
+    try:
+        cfg = json.load(open(os.path.expanduser('~/.routinecode/config.json')))
+        my = cfg.get('tenantId')
+    except Exception:
+        my = None
+    if my in (None, 0, '0', ''):
+        return False
+    return str(entry_tid) == str(my)
+
+
+def find_known_solution(error_text):
+    """에러 텍스트 → 최고 매칭 error-fix 1건 또는 None."""
+    try:
+        if not error_text or not ERROR_HINT.search(error_text):
+            return None
+        if not os.path.exists(EVENTS):
+            return None
+        q_norm = _normalize(error_text)
+        q_tok = _tokens(q_norm)
+        best, best_score = None, 0.0
+        n = 0
+        with open(EVENTS, errors='ignore') as f:
+            for line in f:
+                n += 1
+                if n > MAX_ROWS:
+                    break
+                try:
+                    e = json.loads(line)
+                except Exception:
+                    continue
+                sig = e.get('errorSignature')
+                if not sig or not e.get('rootCause') or not _tenant_ok(e.get('tenantId')):
+                    continue
+                s_norm = _normalize(sig)
+                jac = _jaccard(q_tok, _tokens(s_norm))
+                sub = _common_substr_len(q_norm, s_norm)
+                if sub >= 12 or jac >= 0.5:
+                    score = jac + min(sub, 40) / 40.0
+                    if score > best_score:
+                        best, best_score = e, score
+        return best
+    except Exception:
+        return None
+
+
+def build_injection(e):
+    root = str(e.get('rootCause', ''))[:120]
+    fix = str(e.get('fixApproach', ''))[:120]
+    txt = '[KNOWN-SOLUTION] 과거 동일 에러 해결 이력 — 원인: %s / 해결: %s' % (root, fix)
+    sid = e.get('serverId')
+    if isinstance(sid, int) or (isinstance(sid, str) and sid.isdigit()):
+        # resolvedFromId 는 number 타입 (mcp-intelligence index.ts:164)
+        txt += ' (검증 시 record_verification resolvedFromId=%d)' % int(sid)
+    return txt
+
+
+def _sig8(e):
+    return hashlib.sha1(_normalize(e.get('errorSignature', '')).encode()).hexdigest()[:8]
+
+
+def consume_once(session_id, error_text):
+    """조회+dedup — 세션x시그니처당 1회만 주입문 반환, 그 외 None."""
+    e = find_known_solution(error_text)
+    if not e:
+        return None
+    marker = os.path.join(KN_DIR, '.ks-%s-%s' % (str(session_id)[:12], _sig8(e)))
+    if os.path.exists(marker):
+        return None
+    try:
+        os.makedirs(KN_DIR, exist_ok=True)
+        open(marker, 'w').write(str(int(time.time())))
+        # GC: 24h 초과 .ks-* 자가 정리 (별도 cron 불요 — 설계 v2-2)
+        cutoff = time.time() - 86400
+        for fn in os.listdir(KN_DIR):
+            if fn.startswith('.ks-'):
+                fp = os.path.join(KN_DIR, fn)
+                try:
+                    if os.path.getmtime(fp) < cutoff:
+                        os.remove(fp)
+                except Exception:
+                    pass
+    except Exception:
+        pass
+    return build_injection(e)

package/hooks/lib/receipt.py

@@ -131,6 +131,24 @@ def _fmt_tok(n):
     return str(n)
 
 
+def _fmt_dur(sec):
+    sec = int(sec)
+    if sec >= 3600:
+        return "%dh %dm" % (sec // 3600, (sec % 3600) // 60)
+    if sec >= 60:
+        return "%dm %ds" % (sec // 60, sec % 60)
+    return "%ds" % sec
+
+
+def _time_totals():
+    """Prevented Time 누계 (lib/time_savings.py 원장) — 실패 시 침묵."""
+    try:
+        import time_savings
+        return time_savings.totals()
+    except Exception:
+        return None
+
+
 def build_receipt():
     """전체 영수증 dict — /receipt 렌더 원천."""
     r1 = r1_pooled()
@@ -144,6 +162,7 @@ def build_receipt():
             "r3": {"usd_potential": round(usd_potential, 2),
                    "usd_measured": round(usd_measured, 2),
                    "price_basis": "cache_read $%.2f/M (%s)" % (cr, pr.get('_note', 'prices.json'))},
+            "time": _time_totals(),
             "snapshot": snapshot()}
 
 
@@ -177,6 +196,18 @@ def render(r):
                          % (b["adopted_count"], b["total_uses"]))
     else:
         L.append(" 반복 루틴      아직 감지된 반복 없음 (세션 데이터 축적 중)")
+    t = r.get("time") or {}
+    if t.get("sessions"):
+        parts = []
+        if t.get("measured_s"):
+            parts.append("실측 %s [병렬 서브에이전트]" % _fmt_dur(t["measured_s"]))
+        if t.get("anchored_s"):
+            parts.append("앵커 %s [지식·루틴 — 실측앵커 하한]" % _fmt_dur(t["anchored_s"]))
+        if parts:
+            L.append(" 시간 절감      " + " + ".join(parts))
+        if t.get("potential_gate_blocks"):
+            L.append("                게이트 선차단 %d건 [잠재 — 실측분포 축적 전 미적립]"
+                     % t["potential_gate_blocks"])
     c = r["r3"]
     if c["usd_measured"] > 0:
         L.append(" 환산 가치      실측분 ≈ $%.2f [실측]" % c["usd_measured"])

package/hooks/lib/time_savings.py

@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*-
+"""Prevented Time — 시간절감 적립기 (돈 계산(receipt.py PRICES)과 동형 구조).
+
+대표 케이스(기준값은 time-rates.json 으로 교체 가능, 전부 '보수 하한' 원칙):
+  C1 knowledge_error_reuse : 재발 에러를 지식 조회로 해결. 폴백 60s/건
+                             (2026-10-13 A/B 벤치: 극소형 레포 T1=66s 가 하한 근거.
+                              실측쌍(T1-T2)이 쌓이면 rolling 중앙값으로 자가보정)
+  C2 domain_knowledge_use  : 도메인지식 소비 후 구현. 40s/건
+                             (동일 벤치 실측: opus 탐색태스크 api 131→90s, -40s)
+  C3 parallel_subagents    : 병렬 서브에이전트. 상수 없음 — Σ개별duration - max(duration) 전액 실측
+  C4 mcp_routine           : 루틴을 MCP 1콜로 대체. 수동 대체 하한 상수
+  C5 gate_pre_block        : 게이트 선차단. 실측 분포 축적 전 적립 0 — '잠재 건수'로만 표기
+  (C6 community 는 서버 매칭 — knowledge-service 측 과제)
+
+원칙: 소비 이벤트가 없으면 적립 0. 실측(C3)과 앵커상수(C1/C2/C4)는 분리 집계·표기.
+"""
+import json
+import os
+import sys
+from datetime import datetime, timezone
+
+_RC = os.path.expanduser('~/.routinecode')
+RATES_PATH = os.path.join(_RC, 'rdpe', 'time-rates.json')
+LEDGER = os.path.join(_RC, 'knowledge', 'time-savings.jsonl')
+TELEMETRY = os.path.join(_RC, 'knowledge', 'agent-telemetry.jsonl')
+
+DEFAULT_RATES = {
+    "knowledge_error_reuse_s": 60,     # C1 폴백 (보수 하한)
+    "domain_knowledge_use_s": 40,      # C2 실측 앵커 (2026-10-13 벤치)
+    "mcp_build_check_s": 10,           # C4: 수동 빌드+에러해석 하한
+    "mcp_code_search_s": 15,           # C4: find_files/search_code/dependency_graph
+    "mcp_blast_radius_s": 60,          # C4: 수동 호출체인 추적 하한
+    "mcp_routine_other_s": 5,
+    "session_cap_anchored_s": 600,     # 앵커상수 적립의 세션 상한 (과대적립 방지)
+}
+
+C2_TOOLS = ('get_domain_knowledge', 'get_patterns', 'get_known_quirks')
+C1_TOOLS = ('get_similar_errors',)
+C4_MAP = {
+    'build_check': 'mcp_build_check_s',
+    'find_files': 'mcp_code_search_s',
+    'search_code': 'mcp_code_search_s',
+    'get_dependency_graph': 'mcp_code_search_s',
+    'trace_blast_radius': 'mcp_blast_radius_s',
+    'project_state': 'mcp_routine_other_s',
+    'git_diff_summary': 'mcp_routine_other_s',
+}
+
+
+def _rates():
+    try:
+        with open(RATES_PATH) as f:
+            r = json.load(f)
+        return {**DEFAULT_RATES, **r}
+    except Exception:
+        return dict(DEFAULT_RATES)
+
+
+def _iter_transcript(path):
+    with open(path, errors='ignore') as f:
+        for line in f:
+            try:
+                yield json.loads(line)
+            except Exception:
+                continue
+
+
+def collect(transcript_path):
+    """transcript 1개에서 이벤트 집계 → 시간절감 스냅샷."""
+    rates = _rates()
+    tool_uses = []          # (name, tool_use_id)
+    results = {}            # tool_use_id -> result text
+    had_edit = False
+    gate_blocks = 0
+    session_start = None
+    session_end = None
+    # 훅 주입 소비(C1/C2) — attachment(hook_success) stdout 마커. 주입문 sha1로 dedup
+    # (tool_use 경로와 단일 집합 공유 → 이중계수 차단. 설계 v2-6)
+    injected_c1 = set()
+    injected_c2 = set()
+
+    for o in _iter_transcript(transcript_path):
+        ts = o.get('timestamp')
+        if ts:
+            session_start = session_start or ts
+            session_end = ts
+        att = o.get('attachment') or {}
+        if att.get('type') in ('hook_success', 'hook_blocking_error'):
+            out = str(att.get('stdout', ''))[:2000]
+            if '[KNOWN-SOLUTION]' in out:
+                import hashlib as _h
+                injected_c1.add(_h.sha1(out.split('[KNOWN-SOLUTION]')[1][:200].encode()).hexdigest())
+            if '[DOMAIN KNOWLEDGE]' in out:
+                import hashlib as _h
+                injected_c2.add(_h.sha1(out.split('[DOMAIN KNOWLEDGE]')[1][:200].encode()).hexdigest())
+        raw = None
+        for c in (o.get('message', {}).get('content') or []):
+            if not isinstance(c, dict):
+                continue
+            if c.get('type') == 'tool_use':
+                tool_uses.append((c.get('name', ''), c.get('id', '')))
+                if c.get('name') in ('Edit', 'Write', 'MultiEdit', 'NotebookEdit'):
+                    had_edit = True
+                elif c.get('name') == 'Bash':
+                    # 모델이 Edit 대신 Bash로 파일을 고치는 경우(sed -i/리다이렉션/tee)도 구현 신호
+                    _cmd = str((c.get('input') or {}).get('command', ''))[:500]
+                    if ('sed -i' in _cmd or ' tee ' in _cmd or '>>' in _cmd
+                            or ('>' in _cmd and ('.ts' in _cmd or '.js' in _cmd or '.py' in _cmd or '.json' in _cmd))):
+                        had_edit = True
+            elif c.get('type') == 'tool_result':
+                txt = c.get('content')
+                results[c.get('tool_use_id', '')] = json.dumps(txt, ensure_ascii=False)[:400] if txt else ''
+        if raw is None:
+            raw = json.dumps(o, ensure_ascii=False)[:200]
+        if 'HOOK:design-gate' in raw or 'HOOK:pre-mark-complete' in raw:
+            gate_blocks += 1
+
+    def consumed(tool_id):
+        """빈 결과(미발견)는 소비로 치지 않는다 — '소비 없으면 적립 0' 원칙."""
+        t = results.get(tool_id, '')
+        if len(t) < 80:
+            return False
+        for empty_sig in ('"total": 0', '"count": 0', '"quirks": []', '"local": []', '"patterns": []'):
+            if empty_sig in t:
+                return False
+        return True
+
+    c1 = c2 = 0
+    c4_s = 0
+    for name, tid in tool_uses:
+        short = name.split('__')[-1]
+        if any(k in short for k in C1_TOOLS) and consumed(tid):
+            c1 += 1
+        elif any(k in short for k in C2_TOOLS) and consumed(tid):
+            c2 += 1
+        elif short in C4_MAP:
+            c4_s += rates[C4_MAP[short]]
+
+    # 훅 주입 소비 합산 (동일 게이트·상한 적용 — 설계 v2-6)
+    c1 += len(injected_c1)
+    c2 += len(injected_c2)
+
+    # 지식 소비(C1/C2)는 이후 실제 구현(Edit/Write)이 있어야 적립 — 조회만으론 0
+    if not had_edit:
+        c1 = c2 = 0
+    c1 = min(c1, 2)  # 세션당 보수 상한
+    c2 = min(c2, 3)
+
+    anchored_s = min(
+        c1 * rates['knowledge_error_reuse_s'] + c2 * rates['domain_knowledge_use_s'] + c4_s,
+        rates['session_cap_anchored_s'],
+    )
+
+    # C3 병렬 — agent-telemetry에서 이 세션 시간창 내 배치 실측
+    measured_s = _parallel_savings(session_start, session_end)
+
+    return {
+        'at': datetime.now(timezone.utc).isoformat(),
+        'transcript': os.path.basename(transcript_path),
+        'measured_s': round(measured_s),          # 전액 실측 (병렬)
+        'anchored_s': round(anchored_s),          # 실측앵커 상수 기반
+        'potential_gate_blocks': gate_blocks,     # C5: 적립 0, 잠재 건수만
+        'detail': {'c1_error_reuse': c1, 'c2_domain_use': c2, 'c4_mcp_routine_s': c4_s},
+    }
+
+
+def _parse_iso(s):
+    try:
+        return datetime.fromisoformat(s.replace('Z', '+00:00')).timestamp()
+    except Exception:
+        return None
+
+
+def _parallel_savings(session_start, session_end):
+    """같은 10초 창에 발사된 완료 스폰 배치: Σduration - max(duration)."""
+    if not (session_start and session_end and os.path.exists(TELEMETRY)):
+        return 0.0
+    lo, hi = _parse_iso(session_start), _parse_iso(session_end)
+    if lo is None or hi is None:
+        return 0.0
+    rows = []
+    for line in open(TELEMETRY, errors='ignore'):
+        try:
+            r = json.loads(line)
+        except Exception:
+            continue
+        s, e = _parse_iso(r.get('startedAt', '')), _parse_iso(r.get('completedAt', ''))
+        if s and e and lo - 5 <= s <= hi + 5 and r.get('result') == 'success':
+            rows.append((s, e - s))
+    rows.sort()
+    saved, batch = 0.0, []
+    for s, dur in rows:
+        if batch and s - batch[0][0] > 10:
+            if len(batch) >= 2:
+                ds = [d for _, d in batch]
+                saved += sum(ds) - max(ds)
+            batch = []
+        batch.append((s, dur))
+    if len(batch) >= 2:
+        ds = [d for _, d in batch]
+        saved += sum(ds) - max(ds)
+    return saved
+
+
+def append_ledger(snap):
+    if snap['measured_s'] <= 0 and snap['anchored_s'] <= 0 and snap['potential_gate_blocks'] <= 0:
+        return False
+    os.makedirs(os.path.dirname(LEDGER), exist_ok=True)
+    with open(LEDGER, 'a') as f:
+        f.write(json.dumps(snap, ensure_ascii=False) + '\n')
+    return True
+
+
+def totals():
+    """영수증(receipt.py)용 누계."""
+    t = {'measured_s': 0, 'anchored_s': 0, 'potential_gate_blocks': 0, 'sessions': 0}
+    if not os.path.exists(LEDGER):
+        return t
+    for line in open(LEDGER, errors='ignore'):
+        try:
+            r = json.loads(line)
+        except Exception:
+            continue
+        t['measured_s'] += r.get('measured_s', 0)
+        t['anchored_s'] += r.get('anchored_s', 0)
+        t['potential_gate_blocks'] += r.get('potential_gate_blocks', 0)
+        t['sessions'] += 1
+    return t
+
+
+if __name__ == '__main__':
+    inp = os.environ.get('ROUTINECODE_HOOK_INPUT', '')
+    try:
+        tp = json.loads(inp).get('transcript_path', '') if inp else (sys.argv[1] if len(sys.argv) > 1 else '')
+    except Exception:
+        tp = sys.argv[1] if len(sys.argv) > 1 else ''
+    if tp and os.path.exists(tp):
+        snap = collect(tp)
+        append_ledger(snap)
+        print(json.dumps(snap, ensure_ascii=False))

package/hooks/post-bash-knowledge.sh

@@ -0,0 +1,45 @@
+#!/bin/bash
+# KS(L2): Bash 도구 출력에 에러가 보이면 과거 해결 이력([KNOWN-SOLUTION])을 systemMessage로 주입.
+# 설계: .routinecode/plans/design-knowledge-consumption-loop.md (score 96)
+# - 조회/매칭/dedup 전부 lib/known_solution.py 공유 (L1 user-prompt-submit와 동일 모듈)
+# - PostToolUse에서 systemMessage는 유효 (post-build-check.sh와 동일 포맷)
+# - fail-open: 어떤 실패도 {"continue":true} 무주입
+
+INPUT=$(cat)
+HOOKS_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+ROUTINECODE_HOOK_INPUT="$INPUT" _HOOK_LIB_DIR="$HOOKS_DIR/lib" python3 - <<'PYEOF' 2>/dev/null || echo '{"continue":true}'
+import json, os, re, sys
+
+def emit(obj):
+    print(json.dumps(obj, ensure_ascii=False))
+    sys.exit(0)
+
+try:
+    inp = json.loads(os.environ.get('ROUTINECODE_HOOK_INPUT', '') or '{}')
+except Exception:
+    emit({"continue": True})
+
+session_id = inp.get('session_id') or 'unknown'
+resp = inp.get('tool_response')
+text = json.dumps(resp, ensure_ascii=False) if not isinstance(resp, str) else resp
+if not text:
+    emit({"continue": True})
+
+# 에러 라인만 추출 (마지막 3줄) — 전체 출력 전달 금지(노이즈·성능)
+err_lines = [l for l in text.split('\\n') if re.search(r'(Error|error:|에러|Traceback|Cannot |ERR_|Exception)', l)]
+if not err_lines:
+    emit({"continue": True})
+probe = ' '.join(err_lines[-3:])[:400]
+
+try:
+    sys.path.insert(0, os.environ.get('_HOOK_LIB_DIR', ''))
+    import known_solution
+    msg = known_solution.consume_once(session_id, probe)
+except Exception:
+    msg = None
+
+if msg:
+    emit({"continue": True, "systemMessage": msg})
+emit({"continue": True})
+PYEOF