devez-vibe 1.6.44 → 1.6.45

package/README.md

@@ -10,7 +10,11 @@
 npm install -g devez-vibe
 ```
 
-설치하면 `dvz` 명령을 사용할 수 있습니다.
+설치하면 `dvz` 명령을 사용할 수 있습니다.
+
+설치 과정에서 `luna-loop` 스킬도 Codex와 Claude의 사용자 스킬 경로에 함께 설치됩니다.
+스킬은 자동 적용되지 않으며 `$luna-loop`로 직접 호출해야 합니다. 실제
+`gpt-5.6-luna` 검증을 사용하려면 Codex provider와 Luna 위임 기능이 연결돼 있어야 합니다.
 
 | 요건 | 값 |
 | --- | --- |

package/bridge/claude-agent-sdk-bridge.mjs

@@ -1064,9 +1064,11 @@ async function createSession(params, resumeId) {
     turn: null,
     // Prompts that arrived while a turn was running, run in order afterwards.
     pendingPrompts: [],
-    // Steered prompts whose answer may still need a turn of its own.
-    steerPending: 0,
-    turnSequence: 1,
+    // Steered prompts whose answer may still need a turn of its own.
+    steerPending: 0,
+    // SDK task notifications can prompt the main agent without a host request.
+    automaticTurnsPending: 0,
+    turnSequence: 1,
     itemSequence: 1,
     streamBlocks: new Map(),
     tools: new Map(),
@@ -1896,10 +1898,13 @@ function processSubagentSystemMessage(session, message) {
     running.lastSeenAt = Date.now();
     emitSubagents(session);
     return true;
-  }
-  if (message.subtype === "task_notification") {
-    if (message.ambient === true && message.task_id) {
-      session.ambientSubagentTasks ||= new Set();
+  }
+  if (message.subtype === "task_notification") {
+    if (message.ambient !== true && message.skip_transcript !== true) {
+      session.automaticTurnsPending = (session.automaticTurnsPending || 0) + 1;
+    }
+    if (message.ambient === true && message.task_id) {
+      session.ambientSubagentTasks ||= new Set();
       session.ambientSubagentTasks.add(firstLine(message.task_id, 80));
     }
     const status = firstLine(message.status || "completed", 40);
@@ -2135,19 +2140,25 @@ function finishNotifiedSubagents(session, notifications) {
   }
 }
 
-function processUser(session, message) {
-  // 자식 tool_result의 tool_use_id는 부모 세션의 것과 다른 공간이므로, 부모 흐름에
+function processUser(session, message) {
+  // Resume replays are historical transcript frames, not fresh task results or
+  // prompts. Re-processing their notification XML would invent a new turn.
+  if (message.isReplay === true) return;
+  // 자식 tool_result의 tool_use_id는 부모 세션의 것과 다른 공간이므로, 부모 흐름에
   // 섞이기 전에 서브에이전트 기록으로 보낸다.
   if (message.parent_tool_use_id) {
     recordSubagentResult(session, message);
     return;
   }
-  const notifications = taskNotifications(message);
-  if (notifications.length) {
-    if (!session.turn) beginTurn(session);
-    finishNotifiedSubagents(session, notifications);
-    return;
-  }
+  const notifications = taskNotifications(message);
+  if (notifications.length) {
+    if (!session.turn) {
+      if (session.automaticTurnsPending > 0) session.automaticTurnsPending -= 1;
+      beginTurn(session);
+    }
+    finishNotifiedSubagents(session, notifications);
+    return;
+  }
   const content = Array.isArray(message.message?.content) ? message.message.content : [];
   for (const block of content) {
     if (block.type !== "tool_result") continue;
@@ -2303,7 +2314,7 @@ async function runPendingPrompt(session) {
   }
 }
 
-function finishTurn(session, error, durationMs) {
+function finishTurn(session, error, durationMs) {
   if (!session.turn) return;
   flushPendingPlan(session);
   clearForegroundSubagents(session);
@@ -2312,48 +2323,57 @@ function finishTurn(session, error, durationMs) {
   if (durationMs != null) turn.durationMs = durationMs;
   notify("turn/completed", { threadId: session.id, turn });
   session.turn = null;
-  session.streamBlocks.clear();
-}
-
-async function consume(session) {
-  for await (const message of session.query) {
-    adoptSessionId(session, message.session_id);
-    // A steered prompt answered after its turn already ended still deserves a
-    // turn of its own, or the host would drop every event that follows.
-    if (!session.turn
-      && session.steerPending > 0
-      && !message.parent_tool_use_id
-      && (message.type === "stream_event" || message.type === "assistant")) {
-      session.steerPending -= 1;
-      beginTurn(session);
-    }
-    if (message.type === "stream_event") {
-      if (message.event?.type === "content_block_delta" && (message.event?.delta?.text || message.event?.delta?.thinking)) {
-        if (session.turn) session.turn.sawStreamText = true;
-      }
-      await processStreamEvent(session, message);
-    } else if (message.type === "assistant") processAssistant(session, message);
-    else if (message.type === "user") processUser(session, message);
-    else if (message.type === "result") await processResult(session, message);
-    else if (message.type === "system" && processSubagentSystemMessage(session, message)) {
-      // Structured SDK task lifecycle handled above.
-    }
-    else if (message.type === "system" && message.subtype === "compact_boundary") {
-      noteCompactBoundary(session, message.compact_metadata);
-      notify("thread/compacted", { threadId: session.id });
-    } else if (message.type === "system" && message.subtype === "permission_denied") {
-      rememberPermissionDenial(session, {
-        tool: message.tool_name,
-        toolUseId: message.tool_use_id,
-        reason: message.decision_reason || message.decision_reason_type,
-      });
-    } else if (message.type === "rate_limit_event") {
-      notify("claude/account/updated", { threadId: session.id, rateLimitInfo: message.rate_limit_info });
-    } else if (message.type === "system" && message.subtype === "api_retry") {
-      notify("warning", { threadId: session.id, provider: "Claude", message: `Claude API 재시도 ${message.attempt}/${message.max_retries}` });
-    }
-  }
-}
+  session.streamBlocks.clear();
+}
+
+// A task notification or steered prompt can start a main-agent response after
+// the host's previous turn already closed. Only a booked continuation may open
+// this fallback turn; stale top-level frames from initialization/resume stay out.
+function beginUntrackedTurn(session, message) {
+  if (session.turn || message.parent_tool_use_id) return false;
+  if (message.type !== "stream_event" && message.type !== "assistant") return false;
+  if (session.automaticTurnsPending > 0) session.automaticTurnsPending -= 1;
+  else if (session.steerPending > 0) session.steerPending -= 1;
+  else return false;
+  beginTurn(session);
+  return true;
+}
+
+async function consumeMessage(session, message) {
+  adoptSessionId(session, message.session_id);
+  beginUntrackedTurn(session, message);
+  if (message.type === "stream_event") {
+    if (message.event?.type === "content_block_delta" && (message.event?.delta?.text || message.event?.delta?.thinking)) {
+      if (session.turn) session.turn.sawStreamText = true;
+    }
+    await processStreamEvent(session, message);
+  } else if (message.type === "assistant") processAssistant(session, message);
+  else if (message.type === "user") processUser(session, message);
+  else if (message.type === "result") await processResult(session, message);
+  else if (message.type === "system" && processSubagentSystemMessage(session, message)) {
+    // Structured SDK task lifecycle handled above.
+  }
+  else if (message.type === "system" && message.subtype === "compact_boundary") {
+    noteCompactBoundary(session, message.compact_metadata);
+    notify("thread/compacted", { threadId: session.id });
+  } else if (message.type === "system" && message.subtype === "permission_denied") {
+    rememberPermissionDenial(session, {
+      tool: message.tool_name,
+      toolUseId: message.tool_use_id,
+      reason: message.decision_reason || message.decision_reason_type,
+    });
+  } else if (message.type === "rate_limit_event") {
+    notify("claude/account/updated", { threadId: session.id, rateLimitInfo: message.rate_limit_info });
+  } else if (message.type === "system" && message.subtype === "api_retry") {
+    notify("warning", { threadId: session.id, provider: "Claude", message: `Claude API 재시도 ${message.attempt}/${message.max_retries}` });
+  }
+}
+
+async function consume(session) {
+  for await (const message of session.query) {
+    await consumeMessage(session, message);
+  }
+}
 
 const HANDOFF_HEADER = '<devez_provider_handoff chars="';
 const HANDOFF_SEPARATOR = '">\n';
@@ -3481,14 +3501,185 @@ async function runSelfTest() {
   };
   const captured = [];
   const stdoutWrite = process.stdout.write;
-  process.stdout.write = (chunk) => {
-    captured.push(String(chunk));
-    return true;
-  };
-  try {
-    processUser(lifecycleSession, {
-      message: { content: [{ type: "tool_result", tool_use_id: "toolu_1", content: "launched" }] },
-      tool_use_result: { isAsync: true, status: "async_launched", agentId: "agent-1" },
+  process.stdout.write = (chunk) => {
+    captured.push(String(chunk));
+    return true;
+  };
+  try {
+    const automaticTurnSession = {
+      id: "automatic-turn-self-test",
+      turn: null,
+      turnSequence: 1,
+      itemSequence: 1,
+      steerPending: 0,
+      automaticTurnsPending: 0,
+      streamBlocks: new Map(),
+      tools: new Map(),
+      tasks: new Map(),
+      planCreatePending: false,
+      subagents: new Map([
+        ["toolu_automatic", {
+          id: "toolu_automatic",
+          toolUseId: "toolu_automatic",
+          taskId: "automatic-agent",
+          background: true,
+          name: "Explore",
+          description: "Inspect automatic response",
+          tool: "",
+          startedAt: Date.now(),
+          lastSeenAt: Date.now(),
+        }],
+        ["toolu_automatic_2", {
+          id: "toolu_automatic_2",
+          toolUseId: "toolu_automatic_2",
+          taskId: "automatic-agent-2",
+          background: true,
+          name: "Explore",
+          description: "Inspect a second automatic response",
+          tool: "",
+          startedAt: Date.now(),
+          lastSeenAt: Date.now(),
+        }],
+      ]),
+      knownSubagents: new Map(),
+      hiddenSubagentTasks: new Set(),
+      ambientSubagentTasks: new Set(),
+      subagentPulse: null,
+      models: [],
+      model: "claude:default",
+      pendingPrompts: [],
+      permissionDenials: [],
+      lastContextUsage: null,
+      lastContextWindow: 0,
+      query: {
+        async accountInfo() { return null; },
+        async usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET() { return null; },
+      },
+    };
+    await consumeMessage(automaticTurnSession, {
+      type: "assistant",
+      parent_tool_use_id: null,
+      message: { content: [{ type: "text", text: "stale replay" }] },
+    });
+    if (automaticTurnSession.turn !== null) {
+      throw new Error("Claude stale top-level response incorrectly opened a host turn");
+    }
+    await consumeMessage(automaticTurnSession, {
+      type: "user",
+      isReplay: true,
+      origin: { kind: "task-notification" },
+      parent_tool_use_id: null,
+      message: { content: `<task-notification>
+<task-id>automatic-agent</task-id>
+<tool-use-id>toolu_automatic</tool-use-id>
+<status>completed</status><summary>Historical completion</summary>
+</task-notification>` },
+    });
+    if (automaticTurnSession.turn !== null
+      || automaticTurnSession.automaticTurnsPending !== 0
+      || automaticTurnSession.subagents.size !== 2) {
+      throw new Error("Claude replayed task notification changed live turn state");
+    }
+
+    await consumeMessage(automaticTurnSession, {
+      type: "system",
+      subtype: "task_notification",
+      task_id: "automatic-agent",
+      tool_use_id: "toolu_automatic",
+      status: "completed",
+      summary: "Agent finished",
+    });
+    await consumeMessage(automaticTurnSession, {
+      type: "system",
+      subtype: "task_notification",
+      task_id: "automatic-agent-2",
+      tool_use_id: "toolu_automatic_2",
+      status: "completed",
+      summary: "Second agent finished",
+    });
+    if (automaticTurnSession.subagents.size !== 0
+      || automaticTurnSession.automaticTurnsPending !== 2
+      || automaticTurnSession.turn !== null) {
+      throw new Error("Claude task notifications did not book both automatic turns");
+    }
+    await consumeMessage(automaticTurnSession, {
+      type: "assistant",
+      parent_tool_use_id: "toolu_child",
+      message: { content: [{ type: "text", text: "child" }] },
+    });
+    if (automaticTurnSession.turn !== null
+      || automaticTurnSession.automaticTurnsPending !== 2) {
+      throw new Error("Claude child response consumed the pending main-agent turn");
+    }
+
+    await consumeMessage(automaticTurnSession, {
+      type: "stream_event",
+      parent_tool_use_id: null,
+      event: { type: "message_start" },
+    });
+    await consumeMessage(automaticTurnSession, {
+      type: "stream_event",
+      parent_tool_use_id: null,
+      event: {
+        type: "content_block_start",
+        index: 0,
+        content_block: { type: "text" },
+      },
+    });
+    await consumeMessage(automaticTurnSession, {
+      type: "stream_event",
+      parent_tool_use_id: null,
+      event: {
+        type: "content_block_delta",
+        index: 0,
+        delta: { text: "automatic summary one" },
+      },
+    });
+    await consumeMessage(automaticTurnSession, {
+      type: "stream_event",
+      parent_tool_use_id: null,
+      event: { type: "content_block_stop", index: 0 },
+    });
+    await consumeMessage(automaticTurnSession, {
+      type: "assistant",
+      parent_tool_use_id: null,
+      message: { content: [{ type: "text", text: "automatic summary one" }] },
+    });
+    if (automaticTurnSession.turn === null
+      || automaticTurnSession.automaticTurnsPending !== 1) {
+      throw new Error("Claude streamed automatic response did not open one host turn");
+    }
+    await consumeMessage(automaticTurnSession, {
+      type: "result",
+      is_error: false,
+      modelUsage: {},
+      permission_denials: [],
+      duration_ms: 1,
+    });
+    if (automaticTurnSession.turn !== null) {
+      throw new Error("Claude automatic response did not complete its host turn");
+    }
+
+    await consumeMessage(automaticTurnSession, {
+      type: "assistant",
+      parent_tool_use_id: null,
+      message: { content: [{ type: "text", text: "automatic summary two" }] },
+    });
+    await consumeMessage(automaticTurnSession, {
+      type: "result",
+      is_error: false,
+      modelUsage: {},
+      permission_denials: [],
+      duration_ms: 1,
+    });
+    if (automaticTurnSession.turn !== null
+      || automaticTurnSession.automaticTurnsPending !== 0) {
+      throw new Error("Claude consecutive automatic responses left a pending turn");
+    }
+
+    processUser(lifecycleSession, {
+      message: { content: [{ type: "tool_result", tool_use_id: "toolu_1", content: "launched" }] },
+      tool_use_result: { isAsync: true, status: "async_launched", agentId: "agent-1" },
     });
     finishTurn(lifecycleSession, null, 1);
     if (!lifecycleSession.subagents.has("toolu_1") || lifecycleSession.turn !== null) {
@@ -3784,10 +3975,16 @@ async function runSelfTest() {
     .filter(Boolean)
     .map((line) => JSON.parse(line));
   const lifecycleMethods = lifecycleEvents.map((event) => event.method);
-  if (!lifecycleMethods.includes("turn/subagents/updated")
-    || lifecycleMethods.filter((method) => method === "turn/started").length < 3
-    || !lifecycleEvents.some((event) => event.method === "turn/subagent/line"
-      && event.params?.line?.kind === "error")) {
+  if (!lifecycleMethods.includes("turn/subagents/updated")
+    || lifecycleMethods.filter((method) => method === "turn/started").length < 3
+    || !lifecycleEvents.some((event) => event.method === "item/completed"
+      && event.params?.item?.type === "agentMessage"
+      && event.params.item.text === "automatic summary one")
+    || !lifecycleEvents.some((event) => event.method === "item/completed"
+      && event.params?.item?.type === "agentMessage"
+      && event.params.item.text === "automatic summary two")
+    || !lifecycleEvents.some((event) => event.method === "turn/subagent/line"
+      && event.params?.line?.kind === "error")) {
     throw new Error(`Claude subagent lifecycle events self-test failed: ${lifecycleMethods}`);
   }
   const openingSession = {

package/install-skills.mjs

@@ -0,0 +1,51 @@
+import {
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = dirname(fileURLToPath(import.meta.url));
+const sourceRoot = join(packageRoot, "skills", "luna-loop");
+const userHome = homedir();
+const codexHome = process.env.CODEX_HOME?.trim() || join(userHome, ".codex");
+const claudeHome = process.env.CLAUDE_CONFIG_DIR?.trim() || join(userHome, ".claude");
+
+const targets = [
+  { name: "Codex", path: join(codexHome, "skills", "luna-loop") },
+  { name: "Claude", path: join(claudeHome, "skills", "luna-loop") },
+];
+
+function copyTree(source, destination) {
+  mkdirSync(destination, { recursive: true });
+  for (const entry of readdirSync(source, { withFileTypes: true })) {
+    const sourcePath = join(source, entry.name);
+    const destinationPath = join(destination, entry.name);
+    if (entry.isDirectory()) {
+      copyTree(sourcePath, destinationPath);
+    } else if (entry.isFile()) {
+      copyFileSync(sourcePath, destinationPath);
+    }
+  }
+}
+
+if (!existsSync(join(sourceRoot, "SKILL.md"))) {
+  console.error(`스킬 원본(luna-loop)을 찾지 못했습니다: ${sourceRoot}`);
+  process.exit(1);
+}
+
+let failed = false;
+for (const target of targets) {
+  try {
+    copyTree(sourceRoot, target.path);
+    console.log(`스킬 설치 완료 (${target.name}): ${target.path}`);
+  } catch (error) {
+    failed = true;
+    console.error(`스킬 설치 실패 (${target.name}): ${error instanceof Error ? error.message : error}`);
+  }
+}
+
+if (failed) process.exitCode = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devez-vibe",
-  "version": "1.6.44",
+  "version": "1.6.45",
   "description": "Stable terminal UI for Codex and Claude Agent SDK",
   "keywords": [
     "codex",
@@ -23,6 +23,8 @@
   "files": [
     "bin/dvz.exe",
     "bridge/claude-agent-sdk-bridge.mjs",
+    "install-skills.mjs",
+    "skills/luna-loop/",
     "README.md",
     "LICENSE"
   ],
@@ -35,6 +37,9 @@
   "engines": {
     "node": ">=18"
   },
+  "scripts": {
+    "postinstall": "node install-skills.mjs"
+  },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.3.247"
   }

package/skills/luna-loop/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: luna-loop
+description: 직접 호출한 수정·구현 작업을 독립적인 Luna 검증과 재수정으로 반복 완료하고, 범위가 크면 검증 에이전트를 병렬 배치할 때 사용한다. 자동 선택은 하지 않는다.
+---
+
+# 수정-검증 루프
+
+코드·설정·문서를 실제로 바꾸는 작업에서 완료 기준을 `수정함`으로 끝내지 않는다. 요청의 수용 조건을 정리하고, 변경 후 독립 검증을 거쳐 유효한 문제가 발견되면 원래 작업 맥락에서 재수정한 뒤 검증을 반복한다.
+
+이 스킬은 사용자가 `$luna-loop`로 직접 호출한 경우에만 사용한다. 직접 호출된 경우에는 새 수정 작업뿐 아니라 현재 변경의 검증만 요청된 경우도 수행하며, 호출되지 않은 단순 설명·조사에는 적용하지 않는다.
+
+## 적용 경계
+
+- 구현·수정·버그 해결·리팩터링·UI 변경 또는 현재 변경 검증 요청에 적용한다.
+- 검증만 요청된 경우에는 기준선 확인과 직접 검증·Luna 검증을 수행하고, 확정 문제가 있을 때만 수정을 진행한다.
+- 커밋·푸시·배포·외부 시스템 변경은 사용자가 별도로 요청한 경우에만 수행한다.
+- 기존 미커밋 변경은 기준선으로 보존하고, 이번 작업과 무관한 파일을 되돌리거나 정리하지 않는다.
+
+## 핵심 운영 원칙
+
+1. **주 편집자는 하나로 유지한다.** 검증 에이전트는 기본적으로 읽기 전용이며 파일을 수정하지 않는다. 여러 에이전트의 의견을 주 편집자가 원본 코드와 수용 조건으로 재확인한 뒤에만 수정한다.
+2. **검증 대상과 기준선을 분리한다.** 시작 전에 저장소 지침, 현재 변경, 실행 중인 프로세스, 기존 실패를 확인하고 이번 작업에서 생긴 변경과 이미 존재하던 상태를 구분한다.
+3. **추측을 결함으로 올리지 않는다.** 지적에는 기대 조건, 실제 코드 경로, 재현 방법 또는 사용자 영향이 모두 있어야 한다. 근거가 부족하면 `미확인`으로 남기고 무리하게 수정하지 않는다.
+4. **검증 결과를 꾸며내지 않는다.** Luna를 호출하지 못했거나 테스트·빌드가 실행되지 않았으면 성공으로 표시하지 말고 그 한계를 보고한다.
+
+## 실행 절차
+
+### 1. 기준선과 수용 조건 확정
+
+- 저장소의 `AGENTS.md`, `CLAUDE.md`, 기여 문서와 관련 지침을 먼저 읽는다.
+- 현재 작업 디렉터리, 변경 파일, 실행 중인 프로세스, 기존 테스트·빌드 실패를 확인한다.
+- 사용자의 요구를 관찰 가능한 수용 조건으로 바꾼다. 표시·상태·입력·저장·오류·성능 중 영향을 받는 축을 빠뜨리지 않는다.
+- 변경 파일과 직접 영향을 받는 호출자·피호출자·테스트를 짧은 목록으로 고정한다.
+- 수용 조건마다 가장 값싼 직접 검증 명령이나 실행 경로를 정한다.
+
+### 1-1. Luna 실행 가능성 게이트
+
+- 파일을 수정하기 전에 현재 호스트가 실제 `gpt-5.6-luna`를 위임 실행할 수 있는지 확인한다.
+- Codex에서는 `multi_agent_v1__spawn_agent`가 노출되고 반환된 실행 모델을 `gpt-5.6-luna`로 확인할 수 있어야 한다.
+- Claude에서는 Codex provider와 교차 제공자 Luna 위임 기능이 실제로 연결돼 있어야 한다. Claude 모델이나 직접 검증으로 대체하지 않는다.
+- 게이트를 통과하지 못하면 새 수정은 시작하지 않고 `Luna 검증 불가` 사유와 필요한 연결 상태만 보고한다. 이미 존재하는 변경은 읽기 전용으로 확인할 수 있지만 완료로 판정하지 않는다.
+
+### 2. 최소 범위로 수정
+
+- 기준선과 수용 조건을 벗어나지 않는 가장 작은 일관된 변경을 적용한다.
+- 검증을 쉽게 하려고 무관한 리팩터링, 형식 정리, 테스트 삭제를 끼워 넣지 않는다.
+- 수정 직후 변경 목록과 수용 조건의 대응을 다시 대조한다.
+
+### 3. 주 편집자의 직접 검증
+
+- 가능한 경우 변경 지점에 가장 가까운 단위 테스트·정적 검사·빌드·실행 확인을 먼저 한다.
+- 실패는 `이번 변경의 실패`, `기준선도 실패`, `환경상 실행 불가`로 나눠 기록한다.
+- 직접 검증이 통과해도 독립 검증을 생략하지 않는다. 직접 검증은 실행 가능성, Luna 검증은 놓친 계약·회귀·경계 조건을 확인하는 역할이다.
+
+### 4. Luna 독립 검증
+
+- 실행 가능성 게이트를 통과한 뒤에만 검증 에이전트를 생성한다. 모든 검증자는 실제 `gpt-5.6-luna`로 실행돼야 하며, Luna를 사용할 수 없으면 대체 검증 없이 중단한다.
+- 검증자에게는 요청 요약, 수용 조건, 변경 파일·관련 코드 범위, 기준선 정보, 이미 실행한 검사만 전달한다. 주 편집자의 의심 결론이나 원하는 판정을 전달하지 않는다.
+- 각 검증자는 읽기 전용으로 동작하게 하고, 근거 없는 광범위 탐색이나 파일 수정을 금지한다.
+- 수정과 직접 검증이 끝난 직후, 완료 직전의 최종 검증 패널로 최소 2개의 Luna 검증자를 서로 다른 관점에서 동시에 생성한다.
+- 변경 범위가 크면 독립 범위를 나눠 3~4개의 Luna 검증자를 동시에 생성한다. 다음 중 하나라도 해당하면 큰 변경으로 본다.
+  - 변경 파일이 5개 이상이다.
+  - 서로 다른 하위 시스템이 2개 이상이다.
+  - UI와 상태·저장·통신 로직이 함께 바뀐다.
+  - 수용 조건이 서로 다른 동작 축 3개 이상으로 나뉜다.
+- 병렬 검증의 범위는 겹치지 않게 나눈다. 적합한 축은 `정상 사용 흐름·요구사항`, `회귀·상태·오류 경로`, `테스트·빌드·호환성`, `UI·입력·접근성`이다. UI가 없으면 마지막 축을 만들지 않는다.
+- 모든 검증자의 결과를 받은 뒤 한 번에 종합한다. 같은 문제를 반복 보고한 수는 확신도의 근거가 아니라 한 건의 근거 묶음으로 취급한다.
+- 생성한 각 검증자의 종료 상태를 확인한다. `완료`가 아닌 `오류`·`중단`·`시간 초과`·`상태 미확인`은 해당 범위의 검증 미완료로 기록한다.
+- `오류`·`중단`·`시간 초과`·`상태 미확인`·`Luna 모델 미확인` 범위는 같은 범위의 새 Luna 검증자로 한 번만 재시도한다. 재시도도 완료되지 않으면 추가 재시도·직접 검증·다른 모델 대체 없이 즉시 중단하고 실행 불가 사유와 영향 범위를 보고한다.
+- 검증자가 일부만 끝났다면 끝난 결과는 잠정 결과로만 사용한다. 누락 범위가 있으면 같은 범위의 Luna 검증자를 새로 실행하며, 직접 검증이나 다른 모델로 대체하지 않는다.
+- 병렬 결과가 하나라도 미완료인 채로 남으면 전체를 통과로 판정하지 않는다. 새 Luna 검증자도 실패하면 해당 범위의 실행 불가 사유와 영향 범위를 보고하고 중단한다.
+
+검증자에게 전달할 기본 요청은 [검증자 계약](references/verifier-contract.md)을 따른다.
+
+### 5. 문제 판정과 재수정
+
+- 각 지적을 원본 코드, 수용 조건, 실행 결과로 다시 확인한다. 검증자의 말만으로 수정하지 않는다.
+- 유효한 지적만 `확정 문제`로 채택하고, 의도 확인이 필요한 내용은 `확인 요청`, 근거가 약한 내용은 `미확인`으로 분리한다.
+- 요청·기획·기존 계약을 확인해야만 결정할 수 있는 `확인 요청`은 결함으로 단정하지 않는다. 사용자의 답이 없으면 해당 항목을 완료 차단 사유로 남긴다.
+- 확정 문제를 주 편집자가 수정한 뒤, 영향을 받은 직접 검증을 다시 실행한다.
+- 확정 문제가 하나라도 있으면 수정과 직접 검증을 끝낸 뒤 최종 Luna 검증 패널 전체를 같은 관점으로 다시 병렬 실행한다. 고립된 수정이어도 일부 검증자만 생략하지 않는다.
+- 재검증에서 새로운 확정 문제가 나오면 기본 최대 3회의 수정-검증 회차 안에서 같은 루프를 반복한다. 3회 뒤에도 확정 문제가 남으면 아래 종료 규칙에 따라 중단하며 완료하지 않는다.
+- 반복마다 회차, 채택·기각한 지적과 근거, 새로 바뀐 범위, 실행한 검사를 기록한다. 이전에 통과한 검사를 결과 없이 재사용하지 않는다.
+
+### 6. 종료 판정
+
+다음 조건을 모두 만족할 때만 완료로 판정한다.
+
+- 수용 조건을 위반하는 확정 문제가 남아 있지 않다.
+- 사용자 판단이 필요한 `확인 요청`이 남아 있지 않다. 남아 있다면 완료가 아니라 명시적 중단·질문 상태로 보고한다.
+- 필수 직접 검증이 통과했거나, 실행 불가 사유와 영향 범위가 명확히 기록됐다.
+- 마지막 변경 범위에 대해 실제 실행 모델이 `gpt-5.6-luna`로 확인된 Luna 검증이 끝났다.
+- 기존 실패·미확인 런타임·사용자 확인 필요 항목이 성공으로 숨겨지지 않았다.
+
+기본 수정-검증 회차는 3회까지다. 3회 뒤에도 확정 문제가 남거나 같은 검증이 반복해서 모순되면 무한 재시도하지 말고, 남은 문제·시도한 수정·차단된 검증·사용자에게 필요한 결정을 보고한다. 사용자가 더 반복하라고 명시한 경우에만 회차를 늘린다.
+
+## 제공자 차이
+
+공통 본문은 Codex와 Claude에서 읽을 수 있게 작성한다. 위임 도구와 모델 이름은 [제공자 호환 안내](references/provider-compatibility.md)를 먼저 확인하고, 현재 호스트에 실제로 노출된 기능만 사용한다.
+
+## 결과 보고
+
+최종 보고에는 최소한 `확인된 원인`, `사용자 영향`, `실제 조치`, `직접 검증`, `Luna 검증`, `남은 한계`를 포함한다. 파일 경로·기술 식별자는 원인과 검증 근거를 판단하는 데 필요한 범위만 쓴다.

package/skills/luna-loop/agents/openai.yaml

@@ -0,0 +1,7 @@
+interface:
+  display_name: "루프 검증"
+  short_description: "수정 후 Luna 반복 검증과 병렬 재검수를 자동화"
+  default_prompt: "직접 $luna-loop을 호출해 수정 사항을 검증하고 문제가 남으면 재수정한 뒤 다시 검증해 주세요."
+
+policy:
+  allow_implicit_invocation: false

package/skills/luna-loop/references/provider-compatibility.md

@@ -0,0 +1,23 @@
+# 제공자 호환 안내
+
+## Codex
+
+- `multi_agent_v1__spawn_agent`가 노출돼 있으면 검증자별로 분리된 읽기 전용 작업을 생성한다.
+- 파일을 수정하기 전에 `gpt-5.6-luna` 위임 가능 여부를 확인한다. 사용자가 요청한 Luna 검증은 해당 모델을 명시해 생성하고, 실제 실행 모델을 반환 정보로 확인한다.
+- 모델 지정이 거부되거나 위임 기능이 없거나 실제 모델 식별이 불가능하면 직접 검증·다른 모델·Claude 검증으로 폴백하지 않는다. 새 수정을 중단하고 `Luna 검증 불가` 또는 `Luna 모델 미확인`으로 기록한다.
+- 수정과 직접 검증이 끝나면 서로 다른 관점의 Luna 검증자 2개 이상을 병렬로 생성한다. 큰 변경은 3~4개로 늘리고, 확정 문제를 수정한 뒤에는 전체 검증자 묶음을 다시 병렬 실행한다.
+- 오류·시간 초과·상태 미확인은 같은 범위의 Luna 검증자로 한 번만 재시도한다. 재시도도 실패하면 대체 없이 중단한다.
+
+## Claude
+
+- Claude provider에서도 동일한 `SKILL.md`를 읽을 수 있다. Claude Code의 `Task` 또는 동등한 위임 기능이 실제로 노출된 경우에만 검증자를 생성한다.
+- Claude provider는 동일한 스킬을 읽을 수 있지만, Codex provider와 교차 제공자 `gpt-5.6-luna` 위임 기능이 실제로 연결된 경우에만 실행을 시작한다. Claude 계열 모델만 노출되면 대체하지 않고 중단한다.
+- Claude 검증자는 쓰기 도구·쓰기 권한을 받지 않도록 호스트 기능으로 제한하고, 요청문에도 파일 수정 금지를 명시한다. 읽기 전용을 강제할 수 없으면 Luna 검증 불가로 중단한다.
+- Claude의 계획·위임 도구 이름은 호스트 버전에 따라 달라질 수 있으므로 존재하지 않는 도구를 가정하지 않는다. 교차 제공자 Luna 위임과 실제 모델 식별이 확인되지 않으면 파일을 수정하지 않고 중단한다.
+- Claude에서 Luna 검증을 시작한 뒤에도 실제 실행 모델이 `gpt-5.6-luna`로 확인되지 않으면 검증 실패로 처리하고, Claude 모델이나 직접 검증으로 대체하지 않는다.
+
+## 공통 제한
+
+- 제공자가 무엇이든 검증자는 파일을 수정하지 않는다. 수정은 주 편집자 하나가 수행한다.
+- 서로 다른 제공자의 결과가 충돌하면 양쪽 결과를 사실로 합치지 말고 원본 코드와 실행 결과로 재판정한다.
+- 모델을 호출하지 못한 상태와 접근 불가한 실행 환경은 Luna 검증 불가로 기록하고 완료하지 않는다. 기준선 실패는 Luna 실행 결과와 별도 한계로 기록한다.

package/skills/luna-loop/references/verifier-contract.md

@@ -0,0 +1,45 @@
+# 검증자 계약
+
+검증자는 변경을 고치거나 파일을 쓰지 않고, 독립적인 결함 탐색 결과만 반환한다. 변경의 옳고 그름을 미리 암시하는 문장이나 주 편집자의 의심 목록을 전달하지 않는다.
+
+## 전달할 정보
+
+- 사용자의 요청을 한 문장으로 요약한 내용
+- 관찰 가능한 수용 조건
+- 기준선에서 이미 존재하던 실패와 이번 변경 파일
+- 검토할 코드 범위와 필요한 테스트·빌드·실행 명령
+- `읽기 전용`, `파일 수정 금지`, `근거 없는 추측 금지`라는 제약
+
+## 검증 요청문
+
+```text
+현재 변경을 읽기 전용으로 검토하라. 아래 수용 조건을 기준으로 요구사항 누락,
+기존 동작 회귀, 상태·입력·오류 경로, 경계값, 테스트·빌드·호환성 문제를 찾아라.
+검증자는 파일을 수정하지 말고, 문제가 없으면 없다고 명시하라.
+
+각 지적은 다음을 모두 포함해야 한다.
+- 심각도: 치명적 / 주요 / 경미 / 미확인
+- 위치: 파일과 줄 또는 식별 가능한 코드 범위
+- 기대 조건: 어떤 수용 조건을 위반하는가
+- 근거: 실제 코드 경로와 관찰된 동작
+- 재현: 실행 명령, 입력 또는 재현 불가 사유
+- 영향: 사용자·데이터·호환성에 미치는 결과
+- 제안: 수정 방향만 제시하고 직접 수정하지 말 것
+
+수용 조건:
+{acceptance_criteria}
+
+변경 범위:
+{changed_scope}
+
+기준선 및 이미 실행한 검사:
+{baseline_and_checks}
+```
+
+## 결과 종합 규칙
+
+- 검증자가 찾은 내용은 데이터이며, 주 편집자가 원본과 수용 조건으로 채택 여부를 결정한다.
+- 수용 조건·코드 경로·재현 또는 영향 중 하나라도 빠진 지적은 `미확인`으로 남긴다.
+- 같은 지적을 여러 검증자가 보고해도 한 건으로 합치고, 서로 다른 근거만 병합한다.
+- 검증자만 발견한 새 지적은 원본을 다시 추적해 실제 문제일 때만 채택한다.
+- 주 편집자만 발견한 지적은 독립 검증 결과와 모순될 수 있으므로 직접 재현한 뒤 등급을 정한다.