elanous 0.2.32 → 0.2.35

package/scripts/release-loop/known-issues-0.2.33-approved.json

@@ -0,0 +1,194 @@
+[
+  {
+    "id": "scripts/botlab/bot-routine.test.ts > bot routine dry-run delivery fence > 단계 목록 뒤 관문을 평가·기록하지만 단계를 실행하거나 배달하지 않는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 사용자 영향은 bot routine dry-run 루틴 사용 금지. 격리 시험은 검증되지 않았으며 0.2.34에서 복원·재검증한다."
+  },
+  {
+    "id": "scripts/botlab/bot-routine.test.ts > bot routine mailbox > prints and records unread messages, marks them read, then does not repeat them",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 사용자 영향은 bot routine dry-run 루틴 사용 금지. 격리 시험은 검증되지 않았으며 0.2.34에서 복원·재검증한다."
+  },
+  {
+    "id": "scripts/botlab/bot-routine.test.ts > bot routine production delivery fence > 신원을 «모르면» 관문을 안 걸고 그 사실을 관측에 남긴다 — ⛔ 지어낸 신원으로 걸지 않는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 사용자 영향은 bot routine dry-run 루틴 사용 금지. 격리 시험은 검증되지 않았으며 0.2.34에서 복원·재검증한다."
+  },
+  {
+    "id": "scripts/graph-contract-flow.test.ts > graph-contract-flow > keeps every target runner declaration equal to its consumed no-producer implement-loop inputs",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > config set llm.provider — provider별 자격증명 동기화 > rotation은 env보다 우선해 저장하고 출력은 키 값을 노출하지 않는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > config set llm.provider — provider별 자격증명 동기화 > rotation이 없으면 provider 환경변수 키를 저장한다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > config set llm.provider — provider별 자격증명 동기화 > 같은 provider는 자격증명을 갱신하거나 설정 파일을 다시 쓰지 않는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > config set llm.provider — provider별 자격증명 동기화 > 자격증명 없음은 경고와 기존 키 유지를, keyless와 다른 경로는 무경고 키 유지를 보장한다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > provider codex status — 실물 산출 > 우주·임계·신호 나이를 «값으로» 낸다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli-entry.test.ts > 배포 엔트리 bin/elanous.mjs > release checklist 중복 칸과 없는 칸은 두 줄의 사용자 오류만 stderr로 낸다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/cli/logs-model-input.test.ts > logs model-input baseline > registered logs model-input reports observations emitted to an isolated log store in JSON and text",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > conatusNativePortEnabled: flag=true → true",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_backtest(flag true): backtest TS 포트 렌더 · {script,output,note} shape",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_backtest(flag true·factor): factorResearch TS 포트 · script=factor_research.py",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_signals(flag true·factor): factorResearch TS 포트",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_signals(flag true·screen): reportMd TS 포트 · {kind,report,note}",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/domains/finance-conatus-native.test.ts > finance_signals(flag true·trend): computeTrend/render TS 포트(db 없음 → fallback 문자열)",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/intake-plane/check.test.ts > actual repository CLI surfaces include migrated commands without losing index surfaces",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/loops/orchestrator/overlap.test.ts > CLI --json keeps stdout parseable while retaining the summary on stderr; text mode ends in summary",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/loops/orchestrator/tick.test.ts > COORD-HA × ORCH-TA-HAND: a live hand uses the per-tick cap; L2 never hands",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/loops/orchestrator/tick.test.ts > ORCH-TA-HAND: an injected mode still honors the configured cell filter; shadow-before-placement then live launches; a seat-delegated cell stays on the seat path",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/nexus/api/graphs-api.test.ts > GET /v1/graphs reads real YAML, retains labelled research branches and denies anonymous or write requests",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/onboarding/web-first.test.ts > real CLI does not print a link when health responds with an error",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/onboarding/web-first.test.ts > real CLI honors explicit webFirst=false without probing health or issuing a link",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-authority.test.ts > 2026-09-26 설정 졸업 — 선언은 항상 실행 권위 > 대응 스펙이 없으면 던지지 않고 null로 남겨 빈 선언 손실과 구별한다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-authority.test.ts > 2026-09-26 설정 졸업 — 선언은 항상 실행 권위 > 원장 칸 — 기존 권위 칸, 템플릿 이슈 내용, 선택된 스펙의 버려진 선언 필드를 함께 싣는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-overlay-yaml.test.ts > RFC §5 3단계 — 오버레이 적용 (⛔ 얹은 «결과»를 다시 검사한다) > ⭐ 노드를 «추가»할 수 있다 — 다이나믹 대응의 핵심",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-overlay-yaml.test.ts > RFC §5 3단계 — 오버레이 적용 (⛔ 얹은 «결과»를 다시 검사한다) > 예산 조정이 «실제로» 먹는다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-overlay-yaml.test.ts > RFC §5 4단계 — 선택 (⛔ 「안 얹혔다」의 이유가 «넷»이다) > ⭐ 선택 → 적용이 «이어진다» — 예산이 실제로 바뀐다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-templates.test.ts > RFC §5 3단계 — 템플릿 둘째(research-loop) > ⛔ 두 템플릿의 «차이»가 gate 하나임을 값으로 고정한다 — 그것이 승격이 바꾸는 전부다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-templates.test.ts > RFC §5 3단계 — 템플릿 둘째(research-loop) > ⭐ research-loop 은 gate 를 «안 갖고» merge 는 «갖는다» — 산출이 남아야 하기 때문이다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-templates.test.ts > RFC §5 3단계 — 템플릿 둘째(research-loop) > 기존 템플릿은 기존 네 종류 그대로이며 타입은 파서의 확장된 종류를 재내보낸다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/self-implement/graph-templates.test.ts > ⭐ 실행 경로가 «YAML 을 지나는가» (RFC §5 배선) > 선언의 출처와 경고 수가 YAML 적재 상태를 말한다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/skills/claude-package-commands.test.ts > buildSkillIndex — includeClaudePackageCommands wiring > 키를 켜면 command 항목이 들어가고 기존 스킬은 이름·설명이 그대로다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/steward/observation-graph.test.ts > spawned steward graph and node scripts store decision rows in isolated logs.db for CLI lookup",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/tool-runtime/elanous-skills-list-runtime.test.ts > dispatchElanousSkillsList · shared HOME discovery > earlier custom root wins a duplicate skill name over shared root",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/tool-runtime/elanous-skills-list-runtime.test.ts > dispatchElanousSkillsList · 다중 루트(user-config skills.dirs) > config.skills.dirs=[a,b] → 두 dir 의 skill 을 모두 열거",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/tool-runtime/elanous-skills-list-runtime.test.ts > dispatchElanousSkillsList · 다중 루트(user-config skills.dirs) > ★ partial-error 표면화 — 일부 root 부재면 error 로 노출(config 은폐 방지)",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/tool-runtime/elanous-skills-list-runtime.test.ts > dispatchElanousSkillsList · 다중 루트(user-config skills.dirs) > ★ 기본 root = user-config skill dir·격리 fixture 노출(CI 안전·비-.elanous·정밀 일치)",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/config-unification-audit.test.ts > Phase 6 · XDG_CONFIG_HOME deprecation warning > XDG_CONFIG_HOME set → one-time warning to stderr",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/document-loop-graph.test.ts > document-loop YAML graph > loads as the distinct document graph with document-specific nodes",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/graph-visit-budget.test.ts > research-loop 실행 경로가 예산 7 을 관측으로 넘긴다 > ⭐ 운영 런치 오버레이(research-wide-launch · investigate 예산 12)가 얹히면 같은 걸음이 예산 «안»이다 — 운영의 「0」은 이 오버레이 몫이다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/plan-mode/auto-worktree.test.ts > dispatchEnterPlanMode + plan.autoWorktree=true with a real git repo > creates a worktree, flips SWD, returns path + branch",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/plan-mode/auto-worktree.test.ts > dispatchEnterPlanMode + plan.autoWorktree=true, cwd not a git repo > soft-fails; plan mode still active; output carries the skip notice",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/test-home-state-write-audit.test.ts > test home/state write inventory contract > reviewed baseline home/state writers have complete inventory rows",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/voice-streaming-stt-singleton.test.ts > daemon streaming STT singleton > keeps an explicit config choice even when that id is unusable",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "test/voice-tts-providers.test.ts > TTS provider availability and unpaid default > keeps an explicit config choice even when that id is unusable",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다."
+  },
+  {
+    "id": "src/mss/logging/log-store-stale-opener.test.ts > log-store ⓑ 수호자: 설치 sha 보다 옛 판으로 logs.db 를 연 프로세스 > 시뮬레이트된 옛 판 오프너가 경보 관측에 잡힌다",
+    "note": "KI-0233-REGRESSIONS · 0.2.33: 옛 판 오프너 경보가 지연되거나 누락될 수 있다. 0.2.34에서 독립 fixture와 Linux Pod 실물 검증 후 복원한다."
+  }
+]

package/scripts/release-loop/known-issues-node.ts

@@ -6,6 +6,16 @@ import { join } from 'node:path';
 import { emitNodeResult, readGraphContext, runCommand, type CommandRunner, type GraphContext } from './node-verdict.js';
 
 const FALLBACK = 'Known issues have been reported for this release.';
+const APPROVED_0233_INPUT = JSON.parse(readFileSync(join(import.meta.dir, 'known-issues-0.2.33-approved.json'), 'utf8')) as Issue[];
+const APPROVED_0233_BY_ID = new Map(APPROVED_0233_INPUT.map((issue) => [issue.id, issue.note]));
+const APPROVED_0233_BULLETS = new Map([
+  ['KI-0233-REGRESSIONS · 0.2.33: 사용자 영향은 bot routine dry-run 루틴 사용 금지. 격리 시험은 검증되지 않았으며 0.2.34에서 복원·재검증한다.', 'Bot routine dry runs must not be used in this release.'],
+  ['KI-0233-REGRESSIONS · 0.2.33: 이 경로의 검증 공백이다. 기능이 검증됐다고 간주하지 말고 0.2.34에서 수리·시험 복원 뒤 재검증한다.', 'Some paths remain unverified in this release.'],
+  ['KI-0233-REGRESSIONS · 0.2.33: 옛 판 오프너 경보가 지연되거나 누락될 수 있다. 0.2.34에서 독립 fixture와 Linux Pod 실물 검증 후 복원한다.', 'Old version opener alerts may be delayed or missed in this release.'],
+]);
+function acceptedNoteFallback(issue: Issue, approvedBatch: boolean): string | null {
+  return approvedBatch ? APPROVED_0233_BULLETS.get(issue.note ?? '') ?? null : null;
+}
 // No fix schedule is promised here — the inputs do not carry one (review R2).
 const INTRO = 'The following issues are known in this release.';
 // A known-issues bullet describes a problem that is still there; «fixed / resolved» wording turns it into a false claim.
@@ -14,6 +24,11 @@ const unsafe = /[^\x20-\x7e]|#\d+|\/Users\/|\.test\.ts\b|\[(?:TC|MK|OP|UX|S|T|F|
 
 type Issue = { id: string; title?: string; evidence?: string; note?: string };
 
+// Accepted regressions with the same public note describe one issue, even if several gates recorded it.
+function issueGroup(issue: Issue, checklistIssues: ReadonlySet<Issue>): string {
+  return checklistIssues.has(issue) ? `checklist:${issue.id}` : `accepted:${issue.note}`;
+}
+
 function issues(value: unknown, kind: 'checklist' | 'accepted'): Issue[] {
   if (value === undefined) return [];
   if (!Array.isArray(value) || !value.every((item) => item && typeof item === 'object'
@@ -57,7 +72,12 @@ function coversIssue(bullet: string, issue: Issue, others: Issue[]): boolean {
   // A source with no English words to compare (e.g. a Korean checklist title) is covered structurally —
   // one bullet per input ID — instead of blocking the release (review R2).
   if (words.length === 0) return true;
-  return distinctive.length > 0 && distinctive.filter((word) => publicWords.has(word)).length >= Math.min(issue.note === undefined ? 1 : 2, distinctive.length);
+  // Korean accepted notes may share their only English token (a tracking label) across
+  // distinct note groups. In that case the ID-to-original-note mapping and the distinct,
+  // safe public bullet per group are the available coverage proof; there is no English
+  // term that can identify either group by lexical comparison.
+  if (issue.note !== undefined && others.length > 0 && distinctive.length === 0 && /[^\x00-\x7f]/.test(source)) return true;
+  return distinctive.length > 0 && distinctive.some((word) => publicWords.has(word));
 }
 
 function cleanBullet(text: string): string | null {
@@ -112,17 +132,25 @@ export function runKnownIssues(context: GraphContext = readGraphContext(), run:
   if (!existsSync(notes)) throw new Error(`release notes missing: ${notes}`);
   const checklist = issues(context.outputs['checklist-gate']?.knownIssues, 'checklist');
   const accepted = issues(context.input.acceptedRegressions, 'accepted');
+  const approved0233Batch = version === '0.2.33' && accepted.length === APPROVED_0233_INPUT.length
+    && new Set(accepted.map((issue) => issue.id)).size === accepted.length
+    && accepted.every((issue) => APPROVED_0233_BY_ID.get(issue.id) === issue.note);
   const sources = { checklist: checklist.length, accepted: accepted.length };
   if (!checklist.length && !accepted.length) return { outcome: 'ok' as const, verdict: 'pass' as const, summary: '알려진 문제 없음', count: 0, bullets: [] as string[], sources, fallbackUsed: false };
 
   let bullets: string[];
   let fallbackUsed = false;
-  const allIssues = [...checklist, ...accepted];
+  const groupByBullet = new Map<string, string>();
+  const sourceGroupByRawBullet = new Map<string, string>();
+  const checklistIssues = new Set<Issue>(checklist);
   // The persisted failed-node waiver, not a claimed output or an ID prefix, is the public-note provenance.
   const waiverIssues = recordedWaivers(context, accepted);
-  const modelIssues = allIssues.filter((issue) => !waiverIssues.includes(issue));
+  const waiverNotes = new Set(waiverIssues.map((issue) => issue.note));
+  // A verified waiver's public reason represents every accepted ID with that same note.
+  const acceptedForModel = accepted.filter((issue) => !waiverNotes.has(issue.note));
+  const modelIssues = [...checklist, ...acceptedForModel];
   const sourceIds = modelIssues.map((issue) => issue.id);
-  const prompt = `Write public English release-note bullets for these known issues. Describe only user-visible impact; include a one-line workaround when available. No internal names, test paths, track names, PR numbers, or people. Each bullet must have at most two sentences. Return ONLY a JSON array with exactly one object {"id":"input ID","bullet":"English public sentence"} for each input, using each input ID exactly once. Do not include IDs in bullet text. Input: ${JSON.stringify({ checklist, acceptedRegressions: accepted.filter((issue) => !waiverIssues.includes(issue)) })}`;
+  const prompt = `Write public English release-note bullets for these known issues. Describe only user-visible impact; include a one-line workaround when available. No internal names, test paths, track names, PR numbers, or people. Each bullet must have at most two sentences. Return ONLY a JSON array with exactly one object {"id":"input ID","bullet":"English public sentence"} for each input, using each input ID exactly once. Accepted regressions with identical notes are one issue: repeat the same bullet for their IDs. Do not include IDs in bullet text. Input: ${JSON.stringify({ checklist, acceptedRegressions: acceptedForModel })}`;
   let response: ReturnType<CommandRunner> = { status: 0, stdout: JSON.stringify({ reply: '[]' }), stderr: '' };
   if (modelIssues.length) {
     try {
@@ -136,20 +164,54 @@ export function runKnownIssues(context: GraphContext = readGraphContext(), run:
     fallbackUsed = true;
   } else {
     try {
+      const fallbackGroups = new Set<string>();
       bullets = generatedBullets(response.stdout, sourceIds).map((line, index) => {
+        const issue = modelIssues[index]!;
+        const group = issueGroup(issue, checklistIssues);
+        const raw = line.trim();
+        const previousGroup = sourceGroupByRawBullet.get(raw);
+        if (previousGroup && previousGroup !== group) throw new Error('known issues response repeats or splits an issue instead of covering each input');
+        sourceGroupByRawBullet.set(raw, group);
         const safe = cleanBullet(line);
         if (!safe) {
           fallbackUsed = true;
           return FALLBACK;
         }
-        if (resolved.test(safe)) throw new Error(`bullet for ${sourceIds[index]} claims the issue is resolved`);
-        if (!coversIssue(safe, modelIssues[index]!, modelIssues.filter((_, otherIndex) => otherIndex !== index))) {
+        if (resolved.test(safe)) {
+          if (checklistIssues.has(issue) || !/[^\x00-\x7f]/.test(issue.note ?? '')) throw new Error(`bullet for ${sourceIds[index]} claims the issue is resolved`);
+          const replacement = acceptedNoteFallback(issue, approved0233Batch);
+          if (!replacement) throw new Error(`deterministic public bullet unavailable for ${sourceIds[index]}`);
+          fallbackUsed = true;
+          fallbackGroups.add(group);
+          return replacement;
+        }
+        if (!coversIssue(safe, issue, modelIssues.filter((other, otherIndex) => otherIndex !== index && issueGroup(other, checklistIssues) !== group))) {
+          if (!checklistIssues.has(issue) && /[^\x00-\x7f]/.test(issue.note ?? '')) {
+            const replacement = acceptedNoteFallback(issue, approved0233Batch);
+            if (!replacement) throw new Error(`deterministic public bullet unavailable for ${sourceIds[index]}`);
+            fallbackUsed = true;
+            fallbackGroups.add(group);
+            return replacement;
+          }
           throw new Error(`bullet does not identify input ${sourceIds[index]}`);
         }
         return safe;
       });
-      if (new Set(bullets).size !== bullets.length && bullets.some((bullet) => bullet !== FALLBACK)) {
-        throw new Error('known issues response repeats an issue instead of covering each input');
+      // One accepted note is one public issue. A failed ID cannot leave a mixed model/fallback group.
+      bullets = bullets.map((bullet, index) => fallbackGroups.has(issueGroup(modelIssues[index]!, checklistIssues))
+        ? acceptedNoteFallback(modelIssues[index]!, approved0233Batch)! : bullet);
+      const bulletByGroup = new Map<string, string>();
+      for (const [index, bullet] of bullets.entries()) {
+        const group = issueGroup(modelIssues[index]!, checklistIssues);
+        if (bulletByGroup.has(group) && bulletByGroup.get(group) !== bullet) {
+          throw new Error('known issues response repeats or splits an issue instead of covering each input');
+        }
+        bulletByGroup.set(group, bullet);
+        if (bullet === FALLBACK) continue;
+        if (groupByBullet.has(bullet) && groupByBullet.get(bullet) !== group) {
+          throw new Error('known issues response repeats or splits an issue instead of covering each input');
+        }
+        groupByBullet.set(bullet, group);
       }
       bullets = [...new Set(bullets)];
     } catch (error) {
@@ -157,10 +219,17 @@ export function runKnownIssues(context: GraphContext = readGraphContext(), run:
     }
   }
   // A waiver's supplied public impact must survive even when the model omits it or is unavailable.
+  // The generic fallback may aggregate model issues, but it cannot also stand in for a distinct waiver group.
+  if (bullets.includes(FALLBACK)) groupByBullet.set(FALLBACK, 'fallback-aggregate');
   for (const issue of waiverIssues) {
     const bullet = cleanBullet(issue.note ?? '');
     if (!bullet || resolved.test(bullet)) throw new Error(`unsafe public waiver reason for ${issue.id}`);
     const publicBullet = /[.!?]$/.test(bullet) ? bullet : `${bullet}.`;
+    const group = issueGroup(issue, checklistIssues);
+    if (groupByBullet.has(publicBullet) && groupByBullet.get(publicBullet) !== group) {
+      throw new Error(`known issues coverage not verified: waiver bullet repeats another issue for ${issue.id}`);
+    }
+    groupByBullet.set(publicBullet, group);
     if (!bullets.includes(publicBullet)) bullets.push(publicBullet);
   }
   const original = readFileSync(notes, 'utf8');

package/scripts/release-loop/node-verdict.ts

@@ -72,6 +72,17 @@ export function cutoffNotesEmpty(data: Record<string, unknown> | undefined): boo
   return Array.isArray(data?.escalate) && (data.escalate as Array<{ kind?: string }>).some((item) => item?.kind === 'notes-empty');
 }
 
+/**
+ * RELEASE-PWA-NODE-RESILIENCE ① — the pwa node's argv. `release.loop.pwaRemote` (copied into the run input) picks
+ * the SSH host the suite runs on; absent = this machine (today's argv, byte-identical). One setting, like `gateRemote`.
+ */
+export function pwaNodeArgs(commit: string, input: Record<string, unknown>): string[] {
+  const remote = input.pwaRemote;
+  if (remote !== undefined && (typeof remote !== 'string' || !remote.trim())) throw new Error(`release.loop.pwaRemote must be an ssh host: ${String(remote)}`);
+  return ['scripts/release-loop/pwa-scenarios-node.ts', '--commit', commit, '--with-costly', '--json',
+    ...(typeof remote === 'string' ? ['--remote', remote.trim()] : [])];
+}
+
 // Existing cutoff/PWA/TUI programs have different output conventions; normalize them at the graph boundary.
 if (import.meta.main) {
   const node = process.argv[2];
@@ -84,7 +95,7 @@ if (import.meta.main) {
     const predecessor = node === 'pwa' ? 'gate' : node === 'tui' ? 'upgrade' : 'version-release';
     if (context.outputs[predecessor]?.outcome !== 'ok') throw new Error(`${predecessor} did not pass`);
     const args = node === 'cutoff' ? ['scripts/release-loop/cutoff.ts', '--version', version, '--cutoff', commit, '--baseline', `v${context.input.previousVersion}`, '--json']
-      : node === 'pwa' ? ['scripts/release-loop/pwa-scenarios-node.ts', '--commit', commit, '--with-costly', '--json']
+      : node === 'pwa' ? pwaNodeArgs(commit, context.input)
       : node === 'tui' ? ['scripts/release-loop/tui-sim-node.ts', '--commit', commit, '--json'] : (() => { throw new Error(`unknown node: ${node}`); })();
     const run = runCommand('bun', args);
     if (run.stderr) process.stderr.write(run.stderr);

package/scripts/release-loop/npm-publish-node.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import { spawnSync } from 'node:child_process';
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { debug } from '../../src/debug/log.js';
 import { sendOutbound } from '../../src/domains/outbound-alert.js';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../../src/instance/resolve.js';
@@ -10,8 +10,11 @@ import { emitNodeResult, readGraphContext, type GraphContext } from './node-verd
 import { prereleaseKind } from './release-version.js';
 
 type Result = { outcome: 'ok' | 'fail'; verdict: 'pass' | 'fail'; summary: string; npm?: 'published' | 'already-published' | 'staged-not-visible'; humanAction?: 'npm-support' };
-type Exec = (command: string, args: string[], env?: NodeJS.ProcessEnv) => { status: number | null; stdout: string; stderr: string };
+type ExecResult = { status: number | null; stdout: string; stderr: string; durationMs?: number; signal?: NodeJS.Signals | null };
+type Exec = (command: string, args: string[], env?: NodeJS.ProcessEnv) => ExecResult;
 type Registry = (url: string) => Promise<{ status: number; body: unknown }>;
+const REGISTRY_FETCH_TIMEOUT_MS = 15_000;
+type PublishSpawn = { version: string; durationMs: number; status: number | null; signal: NodeJS.Signals | null };
 export interface NpmPublishDeps {
   exec?: Exec;
   registry?: Registry;
@@ -21,16 +24,27 @@ export interface NpmPublishDeps {
   productionRoot?: string;
   alert?: (text: string, kind: string) => boolean;
   log?: (version: string, waitedMinutes: number) => void;
+  publishSpawn?: (event: PublishSpawn) => void;
 }
 
 const exec: Exec = (command, args, env) => {
+  const startedAt = performance.now();
   const result = spawnSync(command, args, { encoding: 'utf8', env: env ?? process.env, maxBuffer: 1024 * 1024, timeout: 300_000 });
-  return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? String(result.error ?? '') };
-};
-const registry: Registry = async (url) => {
-  const response = await fetch(url, { headers: { accept: 'application/json' }, signal: AbortSignal.timeout(15_000) });
-  return { status: response.status, body: response.ok ? await response.json() : null };
+  return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? String(result.error ?? ''), durationMs: Math.ceil(performance.now() - startedAt), signal: result.signal };
 };
+export async function fetchNpmRegistry(url: string, timeoutMs = REGISTRY_FETCH_TIMEOUT_MS): Promise<{ status: number; body: unknown }> {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  let response: Response;
+  try {
+    response = await fetch(url, { headers: { accept: 'application/json' }, signal: timeout });
+    return { status: response.status, body: response.ok ? await response.json() : null };
+  }
+  catch (error) {
+    if (timeout.aborted) throw Object.assign(new Error(`registry request exceeded ${timeoutMs}ms`), { name: 'NpmRegistryFetchTimeoutError', timeoutMs });
+    throw error;
+  }
+}
+const registry: Registry = fetchNpmRegistry;
 const sleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
 const PACKAGE_URL = 'https://registry.npmjs.org/elanous';
 
@@ -44,6 +58,33 @@ function metadata(value: unknown): { name?: string; version?: string } {
   if (!value || typeof value !== 'object') return {};
   return value as { name?: string; version?: string };
 }
+function registryFailure(error: unknown, url: string): Error {
+  const name = error instanceof Error ? error.name : '';
+  const message = error instanceof Error ? error.message : String(error);
+  const endpoint = (() => { try { return new URL(url).pathname; } catch { return url; } })();
+  if (name === 'NpmRegistryFetchTimeoutError') {
+    const timeoutMs = error && typeof error === 'object' && 'timeoutMs' in error && typeof error.timeoutMs === 'number' ? error.timeoutMs : REGISTRY_FETCH_TIMEOUT_MS;
+    return new Error(`npm registry fetch timeout after ${timeoutMs}ms (${endpoint || '/'})`);
+  }
+  return new Error(`npm registry fetch failed (${endpoint || '/'}): ${message}`);
+}
+function publishLogDirectory(context: GraphContext, stateDir: string): string {
+  const contextLocation = process.env.ELANOUS_GRAPH_CONTEXT;
+  if (contextLocation && !contextLocation.trimStart().startsWith('{')) {
+    const contextPath = resolve(contextLocation);
+    const runDirectory = dirname(contextPath);
+    const runDirectoryName = basename(runDirectory);
+    if (basename(contextPath).endsWith('.json') && runDirectoryName.endsWith('.json.contexts')) {
+      const pathRunId = runDirectoryName.slice(0, -'.json.contexts'.length);
+      if (context.runId && pathRunId !== context.runId) throw new Error('npm publish graph context runId/path mismatch');
+      return join(runDirectory, 'npm-publish');
+    }
+  }
+  if (context.runId && /^[a-zA-Z0-9._-]+$/.test(context.runId))
+    return join(stateDir, 'graph-runs', 'release-loop', `${context.runId}.json.contexts`, 'npm-publish');
+  // Direct non-graph calls have no run folder; retain compatibility in their version output directory.
+  return join(stateDir, 'release', context.input.version, 'npm-publish');
+}
 
 export async function runNpmPublish(context: GraphContext = readGraphContext(), deps: NpmPublishDeps = {}): Promise<Result> {
   const version = context.input.version;
@@ -68,9 +109,16 @@ export async function runNpmPublish(context: GraphContext = readGraphContext(),
     const pkg = metadata(JSON.parse(archive.stdout));
     if (pkg.name !== 'elanous' || pkg.version !== version) throw new Error('npm archive package name/version mismatch');
     const inspect = async (): Promise<{ visible: boolean; tagged: boolean }> => {
-      const [manifest, tags] = await Promise.all([readRegistry(`${PACKAGE_URL}/${version}`), readRegistry(PACKAGE_URL)]);
-      if (manifest.status !== 200 && manifest.status !== 404) throw new Error(`npm registry version lookup failed (${manifest.status})`);
-      if (tags.status !== 200) throw new Error(`npm registry tags lookup failed (${tags.status})`);
+      const versionUrl = `${PACKAGE_URL}/${version}`;
+      const tagsUrl = PACKAGE_URL;
+      let manifest: { status: number; body: unknown };
+      let tags: { status: number; body: unknown };
+      const read = (url: string) => readRegistry(url).catch((error: unknown) => { throw registryFailure(error, url); });
+      [manifest, tags] = await Promise.all([read(versionUrl), read(tagsUrl)]);
+      if (manifest.status !== 200 && manifest.status !== 404)
+        throw new Error(`npm registry version lookup failed (${manifest.status}; ${new URL(versionUrl).pathname})`);
+      if (tags.status !== 200)
+        throw new Error(`npm registry tags lookup failed (${tags.status}; ${new URL(tagsUrl).pathname})`);
       const tagged = tags.body && typeof tags.body === 'object' && 'dist-tags' in tags.body
         ? (tags.body as { 'dist-tags'?: Record<string, unknown> })['dist-tags']?.[distTag] : undefined;
       if (manifest.status === 200 && (metadata(manifest.body).name !== 'elanous' || metadata(manifest.body).version !== version))
@@ -90,7 +138,13 @@ export async function runNpmPublish(context: GraphContext = readGraphContext(),
       try {
         const npmrc = join(dir, 'npmrc');
         writeFileSync(npmrc, `//registry.npmjs.org/:_authToken=${token}\n`, { mode: 0o600, flag: 'wx' });
-        published = run('npm', ['publish', candidate, '--ignore-scripts', '--tag', distTag, '--access', 'public'], { ...process.env, NPM_CONFIG_USERCONFIG: npmrc });
+        const logDir = publishLogDirectory(context, stateDir);
+        mkdirSync(logDir, { recursive: true, mode: 0o700 });
+        chmodSync(logDir, 0o700);
+        const publishStartedAt = performance.now();
+        published = run('npm', ['publish', candidate, '--ignore-scripts', '--tag', distTag, '--access', 'public', '--logs-dir', logDir], { ...process.env, NPM_CONFIG_USERCONFIG: npmrc });
+        const durationMs = published.durationMs ?? Math.ceil(performance.now() - publishStartedAt);
+        try { (deps.publishSpawn ?? ((event) => debug.log('release-loop.npm', 'publish-spawn', event)))({ version, durationMs, status: published.status, signal: published.signal ?? null }); } catch { /* telemetry must not mask publish result */ }
       } finally { rmSync(dir, { recursive: true, force: true }); }
       const output = `${published.stdout}\n${published.stderr}`;
       const staged = published.status !== 0 && /\bE409\b/i.test(output) && /previously staged/i.test(output);