release(platform): 누적 188 PR을 Firebase QA로 배포한다 (#2241)

.github/ISSUE_TEMPLATE/issue.yml

@@ -33,7 +33,8 @@ body:
         - timeletter — 타임레터
         - mindrecord — 마음의 기록
         - home — 홈
-        - platform — Android 앱·CI·빌드·릴리스·저장소 운영
+        - app — 앱 셸·루트 네비게이션·앱 모듈 공통
+        - platform — CI·빌드·릴리스·저장소 운영
     validations:
       required: true
 

.github/ci-expected-failures.json

@@ -1,37 +1,6 @@
 {
   "schemaVersion": 1,
-  "unitTests": [
-    {
-      "task": ":feature:timeletter:data:testDebugUnitTest",
-      "className": "com.afternote.feature.timeletter.data.dto.TimeLetterDtoContractTest",
-      "tests": [
-        "발신 응답의 명시적 null과 빈 배열은 정상 파싱된다",
-        "발신 응답에는 존재하지 않는 deliveredAt 없이 정상 파싱된다",
-        "수신 응답의 기본값 제거 대상 키가 빠지면 실패한다",
-        "수신 응답의 조건부 null과 공개 전 빈 blocks는 정상 파싱된다"
-      ],
-      "issues": [
-        790,
-        873
-      ],
-      "reason": "타임레터 DTO 누락 키 계약 게이트 — 구현 머지 전까지 의도된 실패"
-    }
-  ],
+  "unitTests": [],
   "androidTests": [],
-  "screenshotModules": [
-    {
-      "module": ":feature:setting:presentation",
-      "issues": [
-        1360
-      ],
-      "reason": "설정 화면 screenshotTest용 Content 경계 분리 대기 — compileDebugScreenshotTestKotlin 실패"
-    },
-    {
-      "module": ":feature:timeletter:presentation",
-      "issues": [
-        1361
-      ],
-      "reason": "목록 화면 screenshotTest용 Content 경계 분리 대기 — compileDebugScreenshotTestKotlin 실패"
-    }
-  ]
+  "screenshotModules": []
 }

.github/scripts/audit-org-action-pinning.mjs

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 
 // 조직(orgs/<org>) 하위 전 저장소의 워크플로·composite action 이 쓰는 `uses:` 를
-// 전수로 모아 floating(태그·브랜치) 참조와 40자리 SHA 고정 참조로 가른다.
+// 전수로 모아 floating 액션, 40자리 SHA 고정 액션, 재사용 워크플로로 가른다.
 //
 // `orgs/<org>/actions/permissions` 의 `sha_pinning_required` 를 켜면 조직 하위
-// 저장소 전부에 즉시 적용된다. floating 참조가 하나라도 남아 있으면 그 저장소의
+// 저장소 전부에 즉시 적용된다. floating 액션이 하나라도 남아 있으면 그 저장소의
 // run 은 job 이 만들어지기 전에 `startup_failure` 로 죽고 로그에 사유가 남지 않는다.
-// 그래서 켜기 전에 이 감사를 돌려 0건인지 확인한다.
+// 그래서 켜기 전에 이 감사를 돌려 0건인지 확인한다. 원격 재사용 워크플로는
+// 이 SHA 강제 정책의 예외이며 태그 참조도 허용된다.
 //
 // 사용법:
 //   GH_TOKEN=$(gh auth token) node .github/scripts/audit-org-action-pinning.mjs \
@@ -26,27 +27,39 @@ const PAGE_SIZE = 100;
 
 const WORKFLOW_PATH = /^\.github\/workflows\/[^/]+\.ya?ml$/;
 const ACTION_MANIFEST_PATH = /(?:^|\/)action\.ya?ml$/;
+const REMOTE_REUSABLE_WORKFLOW = /^[^/\s@]+\/[^/\s@]+\/\.github\/workflows\/[^/\s@]+\.ya?ml$/;
 
 /**
- * 워크플로·action 매니페스트 원문에서 `uses:` 값을 순서대로 뽑는다.
+ * 워크플로·action 매니페스트 원문에서 `uses:` 값과 호출 위치를 순서대로 뽑는다.
  *
  * YAML 파서를 쓰지 않는 이유는 `uses:` 가 step 시퀀스·job 레벨(reusable workflow)
- * 양쪽에 나타나고, 주석 처리된 줄은 정책 대상이 아니기 때문이다. 줄 단위로 보는
- * 편이 정책이 보는 범위와 정확히 겹친다.
+ * 양쪽에 나타나기 때문이다. 들여쓰기의 mapping 경로로 jobs.<id>.uses만 구분하고,
+ * step이나 composite action의 같은 경로 문자열에는 워크플로 예외를 적용하지 않는다.
  */
-export function extractActionReferences(source) {
+export function extractActionReferences(source, sourcePath = "") {
     const references = [];
+    const parents = [];
     for (const line of String(source ?? "").split("\n")) {
-        if (/^\s*#/.test(line)) {
+        if (/^\s*(?:#.*)?$/.test(line)) {
             continue;
         }
+        const indent = line.search(/\S/);
+        while (parents.length > 0 && parents.at(-1).indent >= indent) {
+            parents.pop();
+        }
         const match = /^\s*(?:-\s+)?uses:\s*(.+?)\s*$/.exec(line);
-        if (!match) {
-            continue;
+        if (match) {
+            const reference = stripInlineComment(match[1]);
+            const reusableWorkflow = WORKFLOW_PATH.test(sourcePath) &&
+                !line.trimStart().startsWith("-") && parents.length === 2 &&
+                parents[0].key === "jobs" && parents[0].indent === 0;
+            if (reference.length > 0) {
+                references.push({ reference, reusableWorkflow });
+            }
         }
-        const value = stripInlineComment(match[1]);
-        if (value.length > 0) {
-            references.push(value);
+        const mapping = /^\s*(?:([A-Za-z0-9_-]+)|["']([A-Za-z0-9_-]+)["'])\s*:/.exec(line);
+        if (mapping) {
+            parents.push({ indent, key: mapping[1] ?? mapping[2] });
         }
     }
     return references;
@@ -72,10 +85,11 @@ function stripInlineComment(value) {
  *   SHA 고정 정책의 대상이 아니다.
  * - `docker`: `docker://` 참조. 액션 레지스트리가 아니라 이미지라 대상이 아니다.
  * - `expression`: `${{ }}` 가 섞인 참조. 정적으로 판정할 수 없으니 사람이 본다.
+ * - `reusable-workflow`: 버전이 있는 원격 재사용 워크플로. SHA 강제 정책의 예외다.
  * - `pinned`: `@` 뒤가 40자리 소문자 hex.
  * - `floating`: 그 밖(태그 `@v4`·브랜치 `@main`·짧은 SHA). 정책을 켜면 막힌다.
  */
-export function classifyActionReference(reference) {
+export function classifyActionReference(reference, { reusableWorkflow = false } = {}) {
     const value = String(reference ?? "").trim();
     if (value.length === 0) {
         return { reference: value, kind: "empty", action: null, version: null };
@@ -95,6 +109,9 @@ export function classifyActionReference(reference) {
     }
     const action = value.slice(0, separator);
     const version = value.slice(separator + 1);
+    if (reusableWorkflow && version.length > 0 && REMOTE_REUSABLE_WORKFLOW.test(action)) {
+        return { reference: value, kind: "reusable-workflow", action, version };
+    }
     const kind = /^[0-9a-f]{40}$/.test(version) ? "pinned" : "floating";
     return { reference: value, kind, action, version };
 }
@@ -108,7 +125,7 @@ export function classifyActionReference(reference) {
 export function collectExternalActionNames(entries) {
     const names = new Set();
     for (const entry of entries) {
-        if (entry.kind === "pinned" || entry.kind === "floating" || entry.kind === "unversioned") {
+        if (["pinned", "floating", "unversioned", "reusable-workflow"].includes(entry.kind)) {
             names.add(entry.action);
         }
     }
@@ -125,6 +142,7 @@ export function summarizeAudit(entries) {
                 total: 0,
                 pinned: 0,
                 floating: 0,
+                reusableWorkflows: 0,
                 local: 0,
                 other: 0,
                 floatingReferences: [],
@@ -139,6 +157,8 @@ export function summarizeAudit(entries) {
             bucket.floatingReferences.push(entry);
         } else if (entry.kind === "local") {
             bucket.local += 1;
+        } else if (entry.kind === "reusable-workflow") {
+            bucket.reusableWorkflows += 1;
         } else {
             bucket.other += 1;
         }
@@ -152,6 +172,7 @@ export function summarizeAudit(entries) {
             references: entries.length,
             pinned: repositories.reduce((sum, item) => sum + item.pinned, 0),
             floating: repositories.reduce((sum, item) => sum + item.floating, 0),
+            reusableWorkflows: repositories.reduce((sum, item) => sum + item.reusableWorkflows, 0),
             local: repositories.reduce((sum, item) => sum + item.local, 0),
             other: repositories.reduce((sum, item) => sum + item.other, 0),
         },
@@ -259,13 +280,13 @@ async function scanRevision(apiUrl, repository, revision, label, token, blobCach
                 await requestText(`${apiUrl}/repos/${repository}/git/blobs/${blob.sha}`, token),
             );
         }
-        for (const reference of extractActionReferences(blobCache.get(cacheKey))) {
+        for (const { reference, reusableWorkflow } of extractActionReferences(blobCache.get(cacheKey), blob.path)) {
             entries.push({
                 repository,
                 revision,
                 revisionLabel: label,
                 path: blob.path,
-                ...classifyActionReference(reference),
+                ...classifyActionReference(reference, { reusableWorkflow }),
             });
         }
     }
@@ -357,10 +378,10 @@ async function main() {
     console.error(
         `scanned ${scannedRevisions.length} revisions across ${repositories.length} repositories: ` +
             `${totals.references} uses (${totals.pinned} pinned, ${totals.floating} floating, ` +
-            `${totals.local} local, ${totals.other} other)`,
+            `${totals.reusableWorkflows} reusable workflows, ${totals.local} local, ${totals.other} other)`,
     );
     if (!compatible) {
-        console.error("floating references remain; sha_pinning_required would break these runs");
+        console.error("floating action references remain; sha_pinning_required would break these runs");
         process.exitCode = 1;
     }
 }

.github/scripts/audit-org-action-pinning.test.mjs

@@ -25,7 +25,7 @@ test("collects uses from step sequences, job-level reusable workflows, and quote
         "      - uses: ./.github/actions/setup-ci-config",
     ].join("\n");
 
-    assert.deepEqual(extractActionReferences(source), [
+    assert.deepEqual(extractActionReferences(source).map((entry) => entry.reference), [
         "./.github/workflows/lint.yml",
         PINNED,
         "actions/setup-java@dd06d9cba3e5552c54d9f8ea23572deb30010f7c",
@@ -40,7 +40,7 @@ test("ignores commented-out uses lines and run steps that merely mention uses",
         `      - uses: ${PINNED}`,
     ].join("\n");
 
-    assert.deepEqual(extractActionReferences(source), [PINNED]);
+    assert.deepEqual(extractActionReferences(source).map((entry) => entry.reference), [PINNED]);
 });
 
 test("separates SHA-pinned references from every floating form the policy rejects", () => {
@@ -65,6 +65,80 @@ test("exempts the reference kinds the pinning policy does not govern", () => {
     assert.equal(classifyActionReference("actions/checkout").kind, "unversioned");
 });
 
+test("keeps remote reusable workflows compatible and in the allow-list for every supported ref", () => {
+    for (const file of ["build.yml", "build.yaml"]) {
+        for (const version of ["v1", "main", "release/v1", "a".repeat(40)]) {
+            const action = `octo-org/another-repo/.github/workflows/${file}`;
+            const reference = `${action}@${version}`;
+            const classified = classifyActionReference(reference, { reusableWorkflow: true });
+            const summary = summarizeAudit([{ repository: "fixture", ...classified }]);
+
+            assert.deepEqual(classified, { reference, kind: "reusable-workflow", action, version });
+            assert.equal(summary.compatible, true);
+            assert.equal(summary.totals.floating, 0);
+            assert.equal(summary.totals.reusableWorkflows, 1);
+            assert.equal(summary.repositories[0].reusableWorkflows, 1);
+            assert.deepEqual(summary.externalActions, [action]);
+        }
+    }
+});
+
+test("still blocks floating actions when reusable workflows appear in the same audit", () => {
+    const summary = summarizeAudit([
+        "octo-org/another-repo/.github/workflows/build.yml@v1",
+        "gradle/actions/setup-gradle@v6",
+    ].map((reference) => ({ repository: "fixture", ...classifyActionReference(reference, { reusableWorkflow: true }) })));
+
+    assert.equal(summary.compatible, false);
+    assert.equal(summary.totals.reusableWorkflows, 1);
+    assert.equal(summary.totals.floating, 1);
+    assert.deepEqual(summary.repositories[0].floatingReferences.map((entry) => entry.reference), [
+        "gradle/actions/setup-gradle@v6",
+    ]);
+});
+
+test("does not exempt malformed workflow paths or an empty version", () => {
+    for (const reference of [
+        "octo-org/another-repo/.github/workflows/build.yml@",
+        "octo-org/another-repo/.github/workflows/nested/build.yml@v1",
+        "octo-org/another-repo/.github/workflows/build.yml/action.yml@v1",
+        "octo-org/another-repo/.github/workflows/build.txt@v1",
+        "octo-org/another-repo/sub/.github/workflows/build.yml@v1",
+    ]) {
+        const entry = classifyActionReference(reference, { reusableWorkflow: true });
+        assert.equal(entry.kind, "floating", reference);
+        assert.equal(summarizeAudit([{ repository: "fixture", ...entry }]).compatible, false);
+    }
+});
+
+test("applies the exception only at jobs.<id>.uses in workflow files", () => {
+    const reference = "octo-org/another-repo/.github/workflows/build.yml@main";
+    const source = [
+        "jobs:",
+        "  reuse:",
+        `    uses: ${reference}`,
+        "  action:",
+        "    steps:",
+        `      - uses: ${reference}`,
+        "      - name: another action",
+        `        uses: ${reference}`,
+        "  'second-reuse':",
+        `    uses: ${reference}`,
+    ].join("\n");
+    const entries = extractActionReferences(source, ".github/workflows/ci.yml").map((entry) => ({
+        repository: "fixture", ...classifyActionReference(entry.reference, entry),
+    }));
+    assert.deepEqual(entries.map((entry) => entry.kind), [
+        "reusable-workflow", "floating", "floating", "reusable-workflow",
+    ]);
+    assert.equal(summarizeAudit(entries).compatible, false);
+
+    const composite = extractActionReferences(`runs:\n  using: composite\n  steps:\n    - uses: ${reference}`, "action.yml");
+    assert.equal(classifyActionReference(composite[0].reference, composite[0]).kind, "floating");
+    assert.equal(classifyActionReference(reference).kind, "floating");
+    assert.ok(extractActionReferences(source, "action.yml").every((entry) => !entry.reusableWorkflow));
+});
+
 test("keeps the subpath when naming an action, because allow-list wildcards stop at the slash", () => {
     const reference = classifyActionReference("gradle/actions/setup-gradle@v6");
     assert.equal(reference.action, "gradle/actions/setup-gradle");
@@ -100,7 +174,9 @@ test("summarizes per repository and reports incompatibility when any floating re
 
     const summary = summarizeAudit(entries);
     assert.equal(summary.compatible, false);
-    assert.deepEqual(summary.totals, { references: 3, pinned: 1, floating: 1, local: 1, other: 0 });
+    assert.deepEqual(summary.totals, {
+        references: 3, pinned: 1, floating: 1, reusableWorkflows: 0, local: 1, other: 0,
+    });
     assert.deepEqual(
         summary.repositories.map((item) => [item.repository, item.pinned, item.floating]),
         [

.github/scripts/awaiting-author-policy.test.mjs

@@ -2,12 +2,17 @@ import assert from "node:assert/strict";
 import { readFile } from "node:fs/promises";
 import test from "node:test";
 
-import { judgeAwaitingAuthor } from "./label-awaiting-author-prs.mjs";
+import {
+    judgeAwaitingAuthor,
+    parseReviewGateExemptAuthors,
+    planAwaitingAuthorLabels,
+} from "./label-awaiting-author-prs.mjs";
 
 const guard = await readFile(new URL("../workflows/review-debt-guard.yml", import.meta.url), "utf8");
 const reconcile = await readFile(new URL("../workflows/conflict-label.yml", import.meta.url), "utf8");
 const script = await readFile(new URL("./label-awaiting-author-prs.mjs", import.meta.url), "utf8");
 const authorDebtCheck = await readFile(new URL("./check-author-debt.mjs", import.meta.url), "utf8");
+const exemptAuthors = parseReviewGateExemptAuthors(guard);
 
 test("가드는 작성자 무조치를 공통 판정 CLI 로 검사한다", () => {
     // 라벨은 주기 리컨사일 결과라 입장 시점에 스테일할 수 있다. 가드는 live PR 목록을 읽는
@@ -18,6 +23,49 @@ test("가드는 작성자 무조치를 공통 판정 CLI 로 검사한다", () =
     assert.match(script, /export function findAuthorDebts/);
 });
 
+test("라벨 판정은 입장 가드에 선언된 작성자 면제 목록을 직접 읽는다", () => {
+    assert.match(guard, /^\s*REVIEW_GATE_EXEMPT_AUTHORS:/m);
+    assert.match(guard, /\$REVIEW_GATE_EXEMPT_AUTHORS/);
+    assert.match(script, /new URL\("\.\.\/workflows\/review-debt-guard\.yml", import\.meta\.url\)/);
+    assert.doesNotMatch(script, /review-gate-policy\.json/);
+    const mainAt = script.indexOf("async function main()");
+    assert.ok(mainAt > 0);
+    const main = script.slice(mainAt);
+    assert.match(main, /parseReviewGateExemptAuthors\(/);
+    assert.match(main, /planAwaitingAuthorLabels\(\{[^}]*\bexemptAuthors\b/);
+});
+
+test("workflow 파일이 없는 가드 checkout에서도 작성자 빚 판정을 import할 수 있다", async () => {
+    // data URL 에는 상대 workflow 경로가 없다. 모듈을 불러오는 순간 목록을 읽으면
+    // scripts 만 checkout 하는 오래된 가드와 마찬가지로 import가 실패한다.
+    const module = await import(`data:text/javascript;base64,${Buffer.from(script).toString("base64")}`);
+
+    assert.equal(typeof module.findAuthorDebts, "function");
+    assert.equal(typeof module.judgeAwaitingAuthor, "function");
+});
+
+test("가드의 면제 목록에 있는 작성자는 라벨 계획에서도 빠진다", () => {
+    const pullRequests = exemptAuthors.map((login, index) => ({
+        number: index + 1,
+        isDraft: false,
+        author: { login: login.toUpperCase() },
+        labels: { nodes: [{ name: "awaiting-author" }] },
+        reviews: {
+            nodes: [{
+                state: "CHANGES_REQUESTED",
+                submittedAt: "2026-08-29T00:00:00Z",
+                authorCanPushToRepository: true,
+                author: { login: "reviewer" },
+            }],
+        },
+    }));
+    const plan = planAwaitingAuthorLabels({ pullRequests, exemptAuthors });
+
+    assert.deepEqual(plan.toLabel, []);
+    assert.deepEqual(plan.toUnlabel.map((entry) => entry.number), pullRequests.map(({ number }) => number));
+    assert.ok(plan.toUnlabel.every(({ reason }) => reason === "리뷰 게이트 면제 작성자"));
+});
+
 test("리뷰어 빚과 작성자 빚은 한 번의 안내와 종료로 합친다", () => {
     // 두 경로가 각각 댓글·close 를 수행하면 같은 opened 이벤트에서 중복 코멘트와 경합이
     // 생긴다. 두 TSV 를 모두 만든 뒤 한 번만 최종 결정을 내려야 한다.

.github/scripts/check-author-debt.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 
-// 새 PR 작성자가 변경요청을 받은 자기 PR 을 방치하고 있는지 live 상태로 검사한다.
+// 새 PR 을 여는 사람이 변경요청을 받은 «자기가 담당하는» PR 을 방치하고 있는지 live 상태로
+// 검사한다. 담당은 어사인이고 어사인이 비면 작성자다(#1974) — AUTHOR 는 여는 사람의 로그인이지
+// «작성자 필터» 가 아니다.
 // 라벨은 스테일할 수 있으므로 입장 판정에 사용하지 않는다. 열린 PR 을 한 번 조회한 뒤
 // label-awaiting-author-prs.mjs 의 SSOT 판정을 재사용하고, 워크플로가 댓글과 close 를 한 번만
 // 처리할 수 있도록 결과만 TSV 로 넘긴다.