cuelo 0.10.21 → 0.10.23

package/.next/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":93821325,"timestamp":575170,"id":14,"parentId":1,"tags":{},"startTime":1792195703745,"traceId":"b1cf54e2dd52d389"},{"name":"run-typescript","duration":16362368,"timestamp":94770493,"id":11087,"parentId":1,"tags":{},"startTime":1792195797939,"traceId":"b1cf54e2dd52d389"},{"name":"static-check","duration":3743210,"timestamp":111221009,"id":11090,"parentId":1,"tags":{},"startTime":1792195814389,"traceId":"b1cf54e2dd52d389"},{"name":"static-generation","duration":10044206,"timestamp":115058105,"id":11262,"parentId":1,"tags":{},"startTime":1792195818226,"traceId":"b1cf54e2dd52d389"},{"name":"collect-build-traces","duration":16970438,"timestamp":115031605,"id":11259,"parentId":1,"tags":{},"startTime":1792195818200,"traceId":"b1cf54e2dd52d389"},{"name":"telemetry-flush","duration":59,"timestamp":132005996,"id":11271,"parentId":1,"tags":{},"startTime":1792195835174,"traceId":"b1cf54e2dd52d389"},{"name":"next-build","duration":131534973,"timestamp":471099,"id":1,"tags":{"buildMode":"default","version":"16.2.12","bundler":"webpack","has-custom-webpack-config":"true","use-build-worker":"false"},"startTime":1792195703641,"traceId":"b1cf54e2dd52d389"}]
+[{"name":"run-webpack","duration":118341191,"timestamp":692166,"id":14,"parentId":1,"tags":{},"startTime":1792207112919,"traceId":"3028e5e77e38b16d"},{"name":"run-typescript","duration":21384990,"timestamp":119434669,"id":11087,"parentId":1,"tags":{},"startTime":1792207231663,"traceId":"3028e5e77e38b16d"},{"name":"static-check","duration":4272323,"timestamp":140918414,"id":11090,"parentId":1,"tags":{},"startTime":1792207253146,"traceId":"3028e5e77e38b16d"},{"name":"static-generation","duration":13354939,"timestamp":145308193,"id":11262,"parentId":1,"tags":{},"startTime":1792207257536,"traceId":"3028e5e77e38b16d"},{"name":"collect-build-traces","duration":22691837,"timestamp":145285325,"id":11259,"parentId":1,"tags":{},"startTime":1792207257513,"traceId":"3028e5e77e38b16d"},{"name":"telemetry-flush","duration":87,"timestamp":167982010,"id":11271,"parentId":1,"tags":{},"startTime":1792207280210,"traceId":"3028e5e77e38b16d"},{"name":"next-build","duration":167399180,"timestamp":582941,"id":1,"tags":{"buildMode":"default","version":"16.2.12","bundler":"webpack","has-custom-webpack-config":"true","use-build-worker":"false"},"startTime":1792207112810,"traceId":"3028e5e77e38b16d"}]

package/Tools/CUELO_Setup/files/native-runtime-patch.js

@@ -9,7 +9,7 @@ const MEMORY_RE = /(const phase1Model = await resolveMemoryModel\(\{[^}]*?fallba
 const MEMORY_DONE = /const phase1Model = await resolveMemoryModel\(\{[^}]*?fallbackRole: "smol"/;
 const EXPECTED = {
     name: 'cuelo',
-    version: '0.10.21',
+    version: '0.10.23',
     distribution: 'cuelo',
     coreVersion: '18.11.3',
 };

package/Tools/OMP_Global_Config/agent/extensions/docmap-route.ts

@@ -1,34 +1,132 @@
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
-import { routeDocmap } from "./lib/docmap-search";
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import { type DocmapCandidate, type DocmapRoute, routeDocmap } from "./lib/docmap-search";
+import { type CoreJudgmentModules, defaultLoadCore, JUDGE_STOPPED, type NativeJudge, resolveNativeJudge, stoppedBy } from "./lib/native-judge";
 
 // 2026-10-16 재조사(doc/history/2026/10/16-rag-reinvestigation): 격리 표본 12건에서 문서 지도를 연 경우가 0건이었다.
 // 도구나 규칙만 두면 같은 문제가 되풀이되므로, 사용자 요청마다 하네스가 지도·RECORD 헤더 검색을 직접 돌려
 // 후보 기록과 맞는 구간을 그 prompt의 숨은 메시지로 넘긴다. 하한 미만·지도 없음·오류면 아무것도 붙이지 않는다.
 // 안내는 external-advice-check와 같은 이유로 aside가 아니라 그 prompt의 `before_agent_start` 메시지로만 붙인다.
-export default function docmapRoute(pi: ExtensionAPI): void {
-  let pendingText: string | undefined;
-  pi.on("session_start", () => { pendingText = undefined; });
-  pi.on("session_shutdown", () => { pendingText = undefined; });
-  pi.on("input", (event) => {
-    pendingText = undefined;
-    if (event.source !== "interactive" && event.source !== "rpc") return;
-    const text = event.text.trim();
-    if (text) pendingText = text;
+//
+// 2026-10-17 사용자 결정(doc/history/2026/10/17-docmap-judge): 낱말로 고른 후보의 절반은 주제만 겹치는 지시였다
+// (실제 프롬프트 표본 60건 중 맞는 첨부 29·엉뚱한 첨부 31). 낱말·길이·의도 표지로는 둘이 갈리지 않아, 붙이기 전에
+// native JEV에 후보마다 「요청이 가리키는 그 과거 작업의 기록인가」를 한 요청으로 묻고 P>=0.6인 후보만 붙인다(사용자 선택).
+// 같은 표본에서 맞는 첨부 19/29를 지키고 엉뚱한 첨부는 5/31만 남았다(0.5면 23/29·10/31). 판정 실패·제한 시간·native 판정기 없음은
+// 낱말 후보를 그대로 붙이고(재현율 보존), 실행 중 steering·queued 재요청은 판정하지 않는다(스티어링 지연 방지).
+
+export interface DocmapRouteDeps {
+  /** 결정적 판정기 seam(테스트). 없으면 {@link loadCore}의 native JEV를 쓴다. */
+  resolveJudge?: (ctx: ExtensionContext) => Promise<NativeJudge | undefined>;
+  loadCore?: () => Promise<CoreJudgmentModules>;
+  /** 판정 대기 상한. 테스트만 짧게 준다. 기본은 DOCMAP_JUDGE_TIMEOUT_MS다. */
+  judgeTimeoutMs?: number;
+  /** 날짜 의도 판정의 기준 시각(테스트). */
+  now?: () => Date;
+}
+
+/** 판정 대기 상한. 넘으면 낱말 후보를 그대로 붙인다. */
+export const DOCMAP_JUDGE_TIMEOUT_MS = 1_500;
+/** 후보를 남기는 P(관련) 하한. */
+export const DOCMAP_JUDGE_KEEP = 0.6;
+const PROMPT_HEAD_CHARS = 1000;
+const PROMPT_TAIL_CHARS = 1000;
+const CUSTOM_TYPE = "docmap-route";
+
+function judgePrompt(prompt: string): string {
+  return prompt.length <= PROMPT_HEAD_CHARS + PROMPT_TAIL_CHARS ? prompt : `${prompt.slice(0, PROMPT_HEAD_CHARS)}\n…\n${prompt.slice(-PROMPT_TAIL_CHARS)}`;
+}
+
+/** 후보마다 bool 질문 하나. 같은 state를 보므로 한 요청에 묶는다. */
+export function buildDocmapJudgeRequest(prompt: string, route: DocmapRoute): { state: unknown; questions: Record<string, unknown> } {
+  const questions: Record<string, unknown> = {};
+  route.judgeCandidates.forEach((_, i) => {
+    questions[`c${i + 1}`] = {
+      type: "bool",
+      instructions: `Is candidates[${i}] a record of the earlier work the prompt refers to (the same event, decision, procedure or state), not merely sharing words with it? The prompt is one message a user sent to a coding agent mid-conversation; a new instruction, a reaction or small talk that only shares vocabulary is "no".`,
+      criteria: { true: "the prompt asks about or continues the work this record covers", false: "new instruction, reaction, small talk, or only topical word overlap" },
+    };
   });
-  pi.on("before_agent_start", (event, ctx) => {
-    // 대화형·RPC는 사용자 입력과 같은 본문의 prompt에만 붙인다. CUELO의 재개·업데이트 통지와 goal 계속 같은
-    // 내부 prompt는 `input`을 내지 않아(lib/rpc-manager.ts isGenuineUserRequest) 여기서 빠진다.
-    // `omp -p`는 input 이벤트가 없어 최상위 세션의 CLI prompt 자체를 사용자 요청으로 본다. CUELO도 확장을
-    // mode 없이 초기화해 ctx.mode가 "print"이므로, UI 문맥이 없다는 것까지 봐야 CLI로 가를 수 있다.
-    const fromInput = pendingText !== undefined && event.prompt.includes(pendingText);
-    const cliPrompt = (ctx.mode === "print" || ctx.mode === "json") && !ctx.hasUI && ctx.agent?.kind === "main";
-    if (!fromInput && !cliPrompt) return;
-    try {
-      const route = routeDocmap(ctx.cwd, fromInput ? pendingText! : event.prompt);
+  return { state: { prompt: judgePrompt(prompt), candidates: route.judgeCandidates }, questions };
+}
+
+/** 판정 답에서 남길 후보. 답이 없는 후보는 버린다. */
+export function keptByJudge(route: DocmapRoute, answers: Record<string, { bool?: number } | undefined>): DocmapCandidate[] {
+  return route.candidates.filter((_, i) => (answers[`c${i + 1}`]?.bool ?? 0) >= DOCMAP_JUDGE_KEEP);
+}
+
+export function createDocmapRoute(deps: DocmapRouteDeps = {}) {
+  const loadCore = deps.loadCore ?? defaultLoadCore;
+  const resolveJudge = deps.resolveJudge ?? ((ctx: ExtensionContext) => resolveNativeJudge(ctx, loadCore, "docmap_route"));
+  const judgeTimeoutMs = deps.judgeTimeoutMs ?? DOCMAP_JUDGE_TIMEOUT_MS;
+
+  return function docmapRoute(pi: ExtensionAPI): void {
+    let pendingText: string | undefined;
+    let judgePromise: Promise<NativeJudge | undefined> | undefined;
+    /** agent_start~agent_end 사이. 실행 중 steering·queued 재요청은 판정 없이 붙인다(mcp-selection과 같은 추적). */
+    let inRun = false;
+    const judgeFor = (ctx: ExtensionContext) => (judgePromise ??= resolveJudge(ctx).catch(() => undefined));
+
+    pi.on("session_start", () => {
+      pendingText = undefined;
+      judgePromise = undefined;
+      inRun = false;
+    });
+    pi.on("session_shutdown", () => { pendingText = undefined; });
+    pi.on("agent_start", () => { inRun = true; });
+    pi.on("agent_end", () => { inRun = false; });
+    pi.on("input", (event) => {
+      pendingText = undefined;
+      if (event.source !== "interactive" && event.source !== "rpc") return;
+      const text = event.text.trim();
+      if (text) pendingText = text;
+    });
+
+    /** 판정으로 거른 안내문. 판정 실패·제한 시간이면 낱말 후보 그대로. */
+    const filtered = async (route: DocmapRoute, prompt: string, ctx: ExtensionContext): Promise<string> => {
+      const controller = new AbortController();
+      const stopped = stoppedBy(controller.signal);
+      let timedOut = false;
+      const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+      }, judgeTimeoutMs);
+      try {
+        const judge = await Promise.race([judgeFor(ctx), stopped]);
+        if (judge === JUDGE_STOPPED) throw new Error("판정 취소");
+        if (!judge) throw new Error("native JEV 판정기 없음");
+        const result = await Promise.race([judge.judge(buildDocmapJudgeRequest(prompt, route), { signal: controller.signal }), stopped]);
+        if (result === JUDGE_STOPPED) throw new Error("판정 취소");
+        return route.render(keptByJudge(route, result.answers));
+      } catch (error) {
+        pi.logger.debug("docmap-route: JEV 후보 판정 없이 낱말 후보를 붙임", {
+          error: timedOut ? "판정이 제한 시간 안에 끝나지 않음" : error instanceof Error ? error.message : String(error),
+        });
+        return route.text;
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+
+    pi.on("before_agent_start", async (event, ctx) => {
+      // 대화형·RPC는 사용자 입력과 같은 본문의 prompt에만 붙인다. CUELO의 재개·업데이트 통지와 goal 계속 같은
+      // 내부 prompt는 `input`을 내지 않아(lib/rpc-manager.ts isGenuineUserRequest) 여기서 빠진다.
+      // `omp -p`는 input 이벤트가 없어 최상위 세션의 CLI prompt 자체를 사용자 요청으로 본다. CUELO도 확장을
+      // mode 없이 초기화해 ctx.mode가 "print"이므로, UI 문맥이 없다는 것까지 봐야 CLI로 가를 수 있다.
+      const fromInput = pendingText !== undefined && event.prompt.includes(pendingText);
+      const cliPrompt = (ctx.mode === "print" || ctx.mode === "json") && !ctx.hasUI && ctx.agent?.kind === "main";
+      if (!fromInput && !cliPrompt) return;
+      const prompt = fromInput ? pendingText! : event.prompt;
+      let route: DocmapRoute | undefined;
+      try {
+        route = routeDocmap(ctx.cwd, prompt, deps.now?.());
+      } catch {
+        return;
+      }
       if (!route) return;
-      return { message: { customType: "docmap-route", content: route.text, display: false, attribution: "agent" } };
-    } catch {
-      return;
-    }
-  });
+      const content = inRun ? route.text : await filtered(route, prompt, ctx);
+      if (!content) return;
+      return { message: { customType: CUSTOM_TYPE, content, display: false, attribution: "agent" } };
+    });
+  };
 }
+
+export default createDocmapRoute();

package/Tools/OMP_Global_Config/agent/extensions/edit-lessons.ts

@@ -0,0 +1,158 @@
+import { posix, win32 } from "node:path";
+import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+import { MEMORY_SECRET_PATTERN } from "./lib/memory-excerpt";
+
+// 2026-10-17: 저장 교훈은 첫 턴 recall(`<memories>`)과 요청별 docmap-route로만 닿는다. 파일 경로에 묶인 교훈
+// (예: `setup.ps1 -ValidateOnly`는 배포 전에 먼저 돌린다)은 그 파일을 고치는 순간에 필요한데, 그때는 어디서도 다시 오르지 않는다
+// (doc/history/2026/10/05-memory-application, 10/04-memory-followup). 그래서 `edit`·`write`가 호출될 때 대상 경로로 기억을 찾아
+// 그 도구 호출 직후 다음 모델 요청에 단서로 붙인다(tool_call `additionalContext`, 비차단).
+// 안내는 단서일 뿐이다. 도구를 막지 않고, 기억 검색이 없거나 실패하거나 제한 시간을 넘으면 아무것도 붙이지 않는다.
+//
+// 질의·필터 근거(doc/history/2026/10/17-edit-lessons, 은행 사본 실측): 경로를 담은 교훈 123건·파일 81개에서 질의는 상대 경로 그대로가
+// basename만이나 둘을 이은 것보다 낫거나 같았다(상위 8개 안 91/80/92쌍). 검색 결과의 content는 Mnemopi 회상 미리보기라 500자에서 잘려 오므로
+// 파일명이 뒤쪽에 있는 교훈은 basename 필터에서 빠진다(상위 8의 91쌍 중 35쌍). 그 필터를 풀면 그 경로를 가리키지 않는 교훈이 대부분이 되어
+// (보인 243건 중 169건) 단서가 묻히므로 필터는 유지한다. 본문은 공백만 정리해 미리보기 그대로 싣는다(`<memories>`도 원문을 싣는다).
+
+export interface EditLessonsDeps {
+  /** 기억 검색 대기 상한. 테스트만 짧게 준다. 기본은 EDIT_LESSONS_SEARCH_TIMEOUT_MS다. */
+  searchTimeoutMs?: number;
+}
+
+/** 한 호출의 기억 검색 대기 상한. 넘으면 아무것도 붙이지 않고 도구는 그대로 진행한다. */
+export const EDIT_LESSONS_SEARCH_TIMEOUT_MS = 1_500;
+/** 경로 하나에 붙이는 기억 상한. */
+export const EDIT_LESSONS_PER_PATH = 3;
+const SEARCH_LIMIT = 8;
+const LESSON_SOURCES = new Set(["coding-agent-learn", "coding-agent-retain"]);
+
+interface MemoryItem {
+  id?: string;
+  content: string;
+  source?: string;
+  timestamp?: string;
+  score?: number;
+}
+
+/** 입력의 `paths`(문자열 배열)와 `path`를 입력 순서대로 모은다. */
+function inputPaths(input: unknown): string[] {
+  if (!input || typeof input !== "object") return [];
+  const record = input as Record<string, unknown>;
+  const raw: unknown[] = [...(Array.isArray(record.paths) ? record.paths : []), record.path];
+  const paths: string[] = [];
+  for (const value of raw) {
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (trimmed && !paths.includes(trimmed)) paths.push(trimmed);
+  }
+  return paths;
+}
+
+/**
+ * 입력 경로를 cwd 기준으로 정규화한다(역슬래시→`/`, `.`·`..` 정리). cwd 아래면 cwd 기준 `/` 경로, 밖이면 정규화한 절대 경로(`/` 구분).
+ * cwd가 없으면 준 문자열을 posix로 정규화만 한다. 같은 파일을 가리키는 다른 표기가 같은 검색·중복 키가 되게 한다.
+ */
+export function relativeTarget(cwd: string | undefined, path: string): string {
+  // 호스트 플랫폼이 아니라 cwd(없으면 입력)의 모양으로 경로 규칙을 고른다. Windows 러너에서 POSIX 입력에 드라이브가 붙지 않게 한다.
+  const p = /^[A-Za-z]:[\\/]/.test(cwd ?? path) ? win32 : posix;
+  const slashed = path.replace(/\\/g, "/");
+  if (!cwd) return p.normalize(slashed).replace(/\\/g, "/");
+  const abs = p.resolve(cwd, slashed);
+  const rel = p.relative(cwd, abs);
+  if (!rel || rel === ".." || rel.startsWith(`..${p.sep}`) || p.isAbsolute(rel)) return abs.replace(/\\/g, "/");
+  return rel.split(p.sep).join("/");
+}
+
+/** 검색 결과에서 이 경로에 묶인 교훈 후보만 남긴다(출처·basename 일치·id 필요). 같은 id는 처음 것만 둔다. */
+function lessonItems(items: readonly MemoryItem[], base: string): MemoryItem[] {
+  const seen = new Set<string>();
+  return items.filter((item) => {
+    if (typeof item?.id !== "string" || item.id.length === 0 || seen.has(item.id)) return false;
+    if (typeof item.content !== "string" || typeof item.source !== "string" || !LESSON_SOURCES.has(item.source) || !item.content.includes(base)) return false;
+    seen.add(item.id);
+    return true;
+  });
+}
+
+export function createEditLessons(deps: EditLessonsDeps = {}) {
+  const searchTimeoutMs = deps.searchTimeoutMs ?? EDIT_LESSONS_SEARCH_TIMEOUT_MS;
+
+  return function editLessons(pi: ExtensionAPI): void {
+    /** 이 세션에서 이미 찾아 본 경로와 이미 붙인(또는 비밀 패턴으로 가린) 기억 id. */
+    const lookedUp = new Set<string>();
+    const attached = new Set<string>();
+    let sessionGeneration = 0;
+    const reset = (): void => {
+      sessionGeneration++;
+      lookedUp.clear();
+      attached.clear();
+    };
+    pi.on("session_start", reset);
+    pi.on("session_shutdown", reset);
+
+    /** 경로 하나의 후보 기억. 검색 없음·오류·제한 시간·빈 결과는 undefined. */
+    const search = async (ctx: ExtensionContext, path: string): Promise<MemoryItem[] | undefined> => {
+      const memory = ctx.memory;
+      if (!memory) return undefined;
+      const controller = new AbortController();
+      const { promise: timeout, resolve: expire } = Promise.withResolvers<undefined>();
+      const timer = setTimeout(() => {
+        controller.abort();
+        expire(undefined);
+      }, searchTimeoutMs);
+      try {
+        const result = await Promise.race([memory.search(path, { limit: SEARCH_LIMIT, signal: controller.signal }), timeout]);
+        return result?.items?.length ? (result.items as MemoryItem[]) : undefined;
+      } catch (error) {
+        pi.logger.debug("edit-lessons: 기억 검색 없이 진행", { path, error: error instanceof Error ? error.message : String(error) });
+        return undefined;
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+
+    pi.on("tool_call", async (event, ctx) => {
+      if (event.toolName !== "edit" && event.toolName !== "write") return;
+      try {
+        // 같은 경로·같은 id는 병렬 호출에서도 한 번만 다루도록 await 전에 표시한다.
+        const targets: string[] = [];
+        for (const path of inputPaths(event.input)) {
+          const target = relativeTarget(ctx.cwd, path);
+          if (!target || lookedUp.has(target)) continue;
+          lookedUp.add(target);
+          targets.push(target);
+        }
+        if (targets.length === 0) return;
+        const generation = sessionGeneration;
+        const found = await Promise.all(targets.map((target) => search(ctx, target)));
+        // 기다리는 사이 세션이 바뀌었으면(session_start·session_shutdown) 이 결과는 옛 세션 것이라 집합을 건드리지 않고 버린다.
+        if (generation !== sessionGeneration) return;
+        const sections: string[] = [];
+        for (const [index, target] of targets.entries()) {
+          const items = found[index];
+          if (!items) continue;
+          const fresh = lessonItems(items, target.slice(target.lastIndexOf("/") + 1)).filter((item) => !attached.has(item.id!));
+          const withheld = fresh.filter((item) => MEMORY_SECRET_PATTERN.test(item.content));
+          const shown = fresh.filter((item) => !MEMORY_SECRET_PATTERN.test(item.content))
+            .sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
+            .slice(0, EDIT_LESSONS_PER_PATH);
+          if (shown.length + withheld.length === 0) continue;
+          for (const item of [...shown, ...withheld]) attached.add(item.id!);
+          const lines = [`[edit-lessons] ${target}에 묶인 기억 ${shown.length + withheld.length}건. 단서일 뿐이며 현재 지시·정본·승인이 우선한다. 원문은 memory://<id>로 읽는다.`];
+          for (const item of shown) {
+            const date = item.timestamp?.match(/^\d{4}-\d{2}-\d{2}/)?.[0];
+            lines.push(`- ${item.content.replace(/\s+/g, " ").trim()} (id: ${item.id}${date ? `, ${date}` : ""})`);
+          }
+          if (withheld.length > 0) lines.push(`- 비밀 패턴이 있어 보이지 않음: ${withheld.map((item) => item.id).join(", ")}`);
+          sections.push(lines.join("\n"));
+        }
+        if (sections.length === 0) return;
+        return { additionalContext: sections.join("\n\n") };
+      } catch (error) {
+        pi.logger.debug("edit-lessons: 안내 없이 진행", { error: error instanceof Error ? error.message : String(error) });
+        return;
+      }
+    });
+  };
+}
+
+export default createEditLessons();

package/Tools/OMP_Global_Config/agent/extensions/jev-runtime.ts

@@ -10,6 +10,7 @@ import {
   type JobIncarnation,
   type JobObservationClock,
 } from "./lib/job-observation";
+import { MEMORY_SECRET_PATTERN } from "./lib/memory-excerpt";
 import { clearPreparedTaskSession } from "./lib/prepared-task";
 import { createRoutingLedger, DEFAULT_LEDGER_PATH, scopedAttempts, type AttemptIdentity, type DispatchOwnership, type DispatchRecord, type OutcomeRecord, type RevisionRelation, type VerdictRecord } from "./lib/routing-ledger";
 import {
@@ -836,7 +837,6 @@ function renderTodoProgressAdvice(assessment: TodoProgressAssessment): string {
 // emitBeforeAgentStart → 같은 commit으로 메시지 전달). 원문 system prompt·대화·비밀 항목은 보내지 않는다.
 // ---------------------------------------------------------------------------
 
-const MEMORY_SECRET_PATTERN = /(?:^|[\s"'`:])(?:password|passwd|api[_ -]?key|bearer|secret|token|credential|client[_ -]?secret)\b|(?:비밀번호|자격증명|인증키|토큰)|(?:sk-[A-Za-z0-9_-]{12,})/i;
 const MEMORY_ITEM_LIMIT = 8;
 const MEMORY_EXCERPT_CHARS = 500;
 const REQUEST_EXCERPT_CHARS = 1200;

package/Tools/OMP_Global_Config/agent/extensions/lib/docmap-search.ts

@@ -100,11 +100,24 @@ export interface DocmapSection {
   readonly excerpt: string;
 }
 
+/** 후보 하나를 판정기에 보여 주는 모양. 경로·지도 줄·SCOPE·DATE·가장 맞는 절의 발췌만 싣는다. */
+export interface DocmapJudgeCandidate {
+  readonly path: string;
+  readonly map?: string;
+  readonly scope?: string;
+  readonly date?: string;
+  readonly excerpt?: string;
+}
+
 export interface DocmapRoute {
   readonly topScore: number;
   readonly signals: DocmapSignals;
   readonly candidates: readonly DocmapCandidate[];
   readonly text: string;
+  /** 판정기에 넘길 후보 요약. `candidates`와 같은 순서다. */
+  readonly judgeCandidates: readonly DocmapJudgeCandidate[];
+  /** 후보 일부만 남겼을 때의 안내문. 빈 배열이면 빈 문자열. */
+  render(kept: readonly DocmapCandidate[]): string;
 }
 
 /** 소문자 ASCII 낱말(2자 이상)과 한글 연속 구간의 2글자 조각. */
@@ -529,12 +542,17 @@ function clip(text: string, max: number): string {
   return one.length > max ? `${one.slice(0, max - 1)}…` : one;
 }
 
+/** 지도 줄에서 링크 대상·머리 기호·표 구분을 빼고 한 줄로 줄인다. */
+function mapLineText(line: string): string {
+  return clip(line.replace(/\]\([^)]*\)/g, "]").replace(/^[-*]\s*/, "").replace(/\s*\|\s*/g, " "), 200);
+}
+
 export function renderDocmapRoute(corpus: DocmapCorpus, candidates: readonly DocmapCandidate[], sections: ReadonlyMap<string, DocmapSection>, maxChars = DOCMAP_MAX_CHARS): string {
   const blocks = candidates.map((c, i) => {
     const u = c.unit;
     const lines = [`${i + 1}. ${rel(corpus.root, u.file)}${u.fields.STATUS ? ` (STATUS: ${clip(u.fields.STATUS, 60)})` : ""}`];
     if (c.supersededFrom) lines.push(`   대체 전: ${rel(corpus.root, c.supersededFrom)}`);
-    if (u.mapLines[0]) lines.push(`   지도: ${clip(u.mapLines[0].replace(/\]\([^)]*\)/g, "]").replace(/^[-*]\s*/, "").replace(/\s*\|\s*/g, " "), 200)}`);
+    if (u.mapLines[0]) lines.push(`   지도: ${mapLineText(u.mapLines[0])}`);
     else if (u.title) lines.push(`   제목: ${clip(u.title, 160)}`);
     if (u.fields.SCOPE) lines.push(`   SCOPE: ${clip(u.fields.SCOPE, 160)}`);
     const sec = sections.get(u.file);
@@ -572,5 +590,23 @@ export function routeDocmap(cwd: string, prompt: string, now = new Date()): Docm
   if (!docmapPasses(signals)) return undefined;
   const candidates = pickDocmapCandidates(corpus, ranked, DOCMAP_MAX_CANDIDATES, DOCMAP_CANDIDATE_RATIO, docmapDateIntent(prompt, now));
   const sections = bestDocmapSections(candidates.map((c) => c.unit.file), prompt);
-  return { topScore: top.score, signals, candidates, text: renderDocmapRoute(corpus, candidates, sections) };
+  const judgeCandidates = candidates.map((c) => {
+    const u = c.unit;
+    const sec = sections.get(u.file);
+    return {
+      path: rel(corpus.root, u.file),
+      ...(u.mapLines[0] ? { map: mapLineText(u.mapLines[0]) } : u.title ? { map: clip(u.title, 160) } : {}),
+      ...(u.fields.SCOPE ? { scope: clip(u.fields.SCOPE, 160) } : {}),
+      ...(u.fields.DATE ? { date: u.fields.DATE } : {}),
+      ...(sec ? { excerpt: `${clip(sec.heading, 60)}${sec.excerpt ? ` — ${sec.excerpt}` : ""}` } : {}),
+    };
+  });
+  return {
+    topScore: top.score,
+    signals,
+    candidates,
+    text: renderDocmapRoute(corpus, candidates, sections),
+    judgeCandidates,
+    render: (kept) => (kept.length === 0 ? "" : renderDocmapRoute(corpus, kept, sections)),
+  };
 }

package/Tools/OMP_Global_Config/agent/extensions/lib/memory-excerpt.ts

@@ -0,0 +1,5 @@
+// 저장 기억을 판정기나 모델 문맥에 다시 실을 때 비밀을 가리는 공통 패턴. jev-runtime(회상 기억 적용 점검)과
+// edit-lessons(편집 경로 교훈 단서)가 같은 규칙을 쓰도록 한 곳에 둔다.
+
+/** 비밀로 보이는 낱말·접두. 걸리면 내용은 싣지 않고 id만 남긴다. */
+export const MEMORY_SECRET_PATTERN = /(?:^|[\s"'`:])(?:password|passwd|api[_ -]?key|bearer|secret|token|credential|client[_ -]?secret)\b|(?:비밀번호|자격증명|인증키|토큰)|(?:sk-[A-Za-z0-9_-]{12,})/i;

package/Tools/OMP_Global_Config/agent/extensions/lib/native-judge.ts

@@ -0,0 +1,82 @@
+import type { ExtensionContext } from "@oh-my-pi/pi-coding-agent";
+
+/**
+ * core의 native JEV를 확장에서 쓰는 공통 틀. mcp-selection과 docmap-route가 같이 쓴다.
+ * judge 역할의 첫 후보가 native가 아니면 판정하지 않고, 세션 모델 fallback을 붙이지 않으며(sessionModel 미전달),
+ * 체인이 native가 아닌 후보를 내면 그 후보에서는 실행하지 않는다.
+ */
+
+export interface JudgeAnswers {
+  answers: Record<string, { type: string; choice?: string; bool?: number } | undefined>;
+}
+
+/** 판정기 seam. 기본 구현은 native 후보에서만 판정을 실행한다. */
+export interface NativeJudge {
+  judge(request: { state: unknown; questions: Record<string, unknown> }, options?: { signal?: AbortSignal }): Promise<JudgeAnswers>;
+}
+
+export type JudgeKind = "native" | "local" | "online";
+
+interface ChainJudgeLike {
+  withCandidate<T>(run: (judge: NativeJudge, kind: JudgeKind) => Promise<T>, options?: { signal?: AbortSignal }): Promise<T>;
+}
+
+/** 기존 core 판정 모듈. 런타임 값은 host가 해석하고 타입은 여기 필요한 만큼만 둔다. */
+export interface CoreJudgmentModules {
+  judgment: {
+    resolveJudge(deps: {
+      settings: unknown;
+      registry: unknown;
+      sessionId?: string;
+      purpose: string;
+      onUsage?: unknown;
+    }): ChainJudgeLike;
+    hasNativeJudge(settings: unknown, registry: unknown): boolean;
+    journalJudgmentUsage?(manager: unknown): unknown;
+  };
+  settings: { findScopedSettings(cwd?: string): unknown };
+}
+
+export async function defaultLoadCore(): Promise<CoreJudgmentModules> {
+  // 지연 import: 테스트 미러에는 node_modules가 없고, 런타임은 host 번들로 해석한다(jev-runtime과 같다).
+  const [judgment, settings] = await Promise.all([
+    import("@oh-my-pi/pi-coding-agent/judgment"),
+    import("@oh-my-pi/pi-coding-agent/config/settings"),
+  ]);
+  return { judgment, settings } as unknown as CoreJudgmentModules;
+}
+
+export async function resolveNativeJudge(ctx: ExtensionContext, loadCore: () => Promise<CoreJudgmentModules>, purpose: string): Promise<NativeJudge> {
+  const { judgment, settings: settingsModule } = await loadCore();
+  const settings = settingsModule.findScopedSettings(ctx.cwd);
+  if (!settings) throw new Error("세션 설정을 찾지 못함");
+  if (!judgment.hasNativeJudge(settings, ctx.modelRegistry)) throw new Error("judge 역할 첫 후보가 native JEV가 아님");
+  const chain = judgment.resolveJudge({
+    settings,
+    registry: ctx.modelRegistry,
+    sessionId: ctx.sessionManager?.getSessionId?.(),
+    purpose,
+    onUsage: judgment.journalJudgmentUsage?.(ctx.sessionManager),
+  });
+  return {
+    judge: (request, options) =>
+      chain.withCandidate(
+        (candidate, kind) =>
+          kind === "native" ? candidate.judge(request, options) : Promise.reject(new Error(`native가 아닌 judge 후보(${kind})`)),
+        options,
+      ),
+  };
+}
+
+/** 취소·제한 시간이 판정보다 먼저 끝났음을 나타내는 race 표지. */
+export const JUDGE_STOPPED: unique symbol = Symbol("judge-stopped");
+
+/**
+ * `signal`이 끊기면 바로 돌아오는 promise. provider가 signal을 무시해도 호출부가 `Promise.race`로 제때 빠져나온다.
+ */
+export function stoppedBy(signal: AbortSignal): Promise<typeof JUDGE_STOPPED> {
+  const stopped = Promise.withResolvers<typeof JUDGE_STOPPED>();
+  if (signal.aborted) stopped.resolve(JUDGE_STOPPED);
+  else signal.addEventListener("abort", () => stopped.resolve(JUDGE_STOPPED), { once: true });
+  return stopped.promise;
+}

package/Tools/OMP_Global_Config/agent/extensions/mcp-selection.ts

@@ -16,6 +16,9 @@ import {
   summarizeProjectStack,
   VERIFIED_CATALOG,
 } from "./lib/mcp-selection";
+import { type CoreJudgmentModules, defaultLoadCore, JUDGE_STOPPED, type NativeJudge, resolveNativeJudge, stoppedBy } from "./lib/native-judge";
+
+export type { CoreJudgmentModules, NativeJudge } from "./lib/native-judge";
 
 /**
  * 요청별 MCP 선택(`mcp.selection: per-request`). 패치된 core가 매 사용자 요청의 system prompt를 만들기
@@ -26,37 +29,6 @@ import {
  * `mcp_select`를 모르는 core(standalone omp 등)에서는 핸들러가 호출되지 않아 아무 일도 하지 않는다.
  */
 
-interface JudgeAnswers {
-  answers: Record<string, { type: string; choice?: string } | undefined>;
-}
-
-/** 판정기 seam. 기본 구현은 native 후보에서만 판정을 실행한다. */
-export interface NativeJudge {
-  judge(request: { state: unknown; questions: Record<string, unknown> }, options?: { signal?: AbortSignal }): Promise<JudgeAnswers>;
-}
-
-type JudgeKind = "native" | "local" | "online";
-
-interface ChainJudgeLike {
-  withCandidate<T>(run: (judge: NativeJudge, kind: JudgeKind) => Promise<T>, options?: { signal?: AbortSignal }): Promise<T>;
-}
-
-/** 기존 core 판정 모듈. 런타임 값은 host가 해석하고 타입은 여기 필요한 만큼만 둔다. */
-export interface CoreJudgmentModules {
-  judgment: {
-    resolveJudge(deps: {
-      settings: unknown;
-      registry: unknown;
-      sessionId?: string;
-      purpose: string;
-      onUsage?: unknown;
-    }): ChainJudgeLike;
-    hasNativeJudge(settings: unknown, registry: unknown): boolean;
-    journalJudgmentUsage?(manager: unknown): unknown;
-  };
-  settings: { findScopedSettings(cwd?: string): unknown };
-}
-
 export interface McpSelectionDeps {
   /** 결정적 판정기 seam(테스트). 없으면 {@link loadCore}의 native JEV를 쓴다. */
   resolveJudge?: (ctx: ExtensionContext) => Promise<NativeJudge | undefined>;
@@ -89,8 +61,6 @@ const STACK_DIR_LIMIT = 40;
 /** 새 요청의 판정 대기 상한. 넘으면 판정을 취소하고 판정 실패와 같게 새 연결 없이 진행한다(runner 30초 제한에 기대지 않는다). */
 const MCP_SELECTION_TIMEOUT_MS = 3_000;
 const JUDGE_TIMEOUT_REASON = "판정이 제한 시간 안에 끝나지 않음";
-/** 취소·제한 시간이 판정보다 먼저 끝났음을 나타내는 race 표지. */
-const STOPPED: unique symbol = Symbol("mcp-selection-stopped");
 
 async function readJson(path: string): Promise<Record<string, unknown> | undefined> {
   try {
@@ -167,46 +137,11 @@ async function readProjectStack(cwd: string): Promise<string> {
   return summarizeProjectStack({ fileNames, dependencyNames });
 }
 
-async function defaultLoadCore(): Promise<CoreJudgmentModules> {
-  // 지연 import: 테스트 미러에는 node_modules가 없고, 런타임은 host 번들로 해석한다(jev-runtime과 같다).
-  const [judgment, settings] = await Promise.all([
-    import("@oh-my-pi/pi-coding-agent/judgment"),
-    import("@oh-my-pi/pi-coding-agent/config/settings"),
-  ]);
-  return { judgment, settings } as unknown as CoreJudgmentModules;
-}
-
-/**
- * 기존 native JEV만 쓴다. judge 역할의 첫 후보가 native가 아니면 판정하지 않고, 세션 모델 fallback을
- * 붙이지 않으며(sessionModel 미전달), 체인이 native가 아닌 후보를 내면 그 후보에서는 실행하지 않는다.
- */
-async function resolveNativeJudge(ctx: ExtensionContext, loadCore: () => Promise<CoreJudgmentModules>): Promise<NativeJudge> {
-  const { judgment, settings: settingsModule } = await loadCore();
-  const settings = settingsModule.findScopedSettings(ctx.cwd);
-  if (!settings) throw new Error("세션 설정을 찾지 못함");
-  if (!judgment.hasNativeJudge(settings, ctx.modelRegistry)) throw new Error("judge 역할 첫 후보가 native JEV가 아님");
-  const chain = judgment.resolveJudge({
-    settings,
-    registry: ctx.modelRegistry,
-    sessionId: ctx.sessionManager?.getSessionId?.(),
-    purpose: "mcp_selection",
-    onUsage: judgment.journalJudgmentUsage?.(ctx.sessionManager),
-  });
-  return {
-    judge: (request, options) =>
-      chain.withCandidate(
-        (candidate, kind) =>
-          kind === "native" ? candidate.judge(request, options) : Promise.reject(new Error(`native가 아닌 judge 후보(${kind})`)),
-        options,
-      ),
-  };
-}
-
 export function createMcpSelection(deps: McpSelectionDeps = {}) {
   const agentDir = deps.agentDir ?? join(import.meta.dir, "..");
   const catalog = deps.catalog ?? VERIFIED_CATALOG;
   const loadCore = deps.loadCore ?? defaultLoadCore;
-  const resolveJudge = deps.resolveJudge ?? ((ctx: ExtensionContext) => resolveNativeJudge(ctx, loadCore));
+  const resolveJudge = deps.resolveJudge ?? ((ctx: ExtensionContext) => resolveNativeJudge(ctx, loadCore, "mcp_selection"));
   const judgeTimeoutMs = deps.judgeTimeoutMs ?? MCP_SELECTION_TIMEOUT_MS;
 
   return function mcpSelection(pi: ExtensionAPI): void {
@@ -280,22 +215,20 @@ export function createMcpSelection(deps: McpSelectionDeps = {}) {
       const answers: Record<string, string | undefined> = {};
       const signal = event.signal ? AbortSignal.any([event.signal, token.controller.signal]) : token.controller.signal;
       // provider가 signal을 무시해도 취소·제한 시간에 바로 돌아온다.
-      const stopped = Promise.withResolvers<typeof STOPPED>();
-      if (signal.aborted) stopped.resolve(STOPPED);
-      else signal.addEventListener("abort", () => stopped.resolve(STOPPED), { once: true });
+      const stopped = stoppedBy(signal);
       let timedOut = false;
       const timer = setTimeout(() => {
         timedOut = true;
         token.controller.abort();
       }, judgeTimeoutMs);
       try {
-        const judge = await Promise.race([judgeFor(ctx), stopped.promise]);
-        if (judge === STOPPED) throw new Error("판정 취소");
+        const judge = await Promise.race([judgeFor(ctx), stopped]);
+        if (judge === JUDGE_STOPPED) throw new Error("판정 취소");
         if (!judge) throw new Error("JEV 판정기를 해석하지 못함");
-        const stack = await Promise.race([projectStack, stopped.promise]);
-        if (stack === STOPPED) throw new Error("판정 취소");
-        const result = await Promise.race([judge.judge(buildJudgeRequest(cue, stack, candidates), { signal }), stopped.promise]);
-        if (result === STOPPED) throw new Error("판정 취소");
+        const stack = await Promise.race([projectStack, stopped]);
+        if (stack === JUDGE_STOPPED) throw new Error("판정 취소");
+        const result = await Promise.race([judge.judge(buildJudgeRequest(cue, stack, candidates), { signal }), stopped]);
+        if (result === JUDGE_STOPPED) throw new Error("판정 취소");
         for (const [key, answer] of Object.entries(result.answers)) {
           answers[key] = answer?.type === "choice" ? answer.choice : undefined;
         }