seokang-sk 0.7.1 → 0.7.2

package/README.MD

@@ -418,7 +418,9 @@ sk search "reviewer"
 - OWNER: canonical `main`/`master` 직접 push, contributor PR 검토·merge, production 배포, npm publish, rollback, tag/release
 - NON_OWNER: canonical `main`/`master` push와 모든 배포 mutation 금지, 개인 fork 작업 branch와 원본 PR까지만 허용
 
-PR 처리는 예약 Inbox 자동화 없이 `$sk-git`에서 끝냅니다. OWNER가 canonical product repository에서 plain `$sk-git`을 호출하면 현재 저장소의 허용된 contributor PR을 자동 발견해 remote diff를 검토하고 안전조건을 재검증한 뒤 순차 squash merge합니다. 특정 PR 하나만 처리하려면 `$sk-git PR #<number> 병합`을 사용합니다. 친구는 personal fork에서 commit/push/PR까지만 수행하고, merge 뒤 다음 `$sk-git`/feature/bugfix 시작 시 clean/ff-only 조건에서 원본 최신 main을 local default branch에 반영합니다. `sk update`는 제품 코드 pull이 아니라 공용 skill 업데이트에만 사용합니다.
+PR 처리는 예약 Inbox 자동화 없이 `$sk-git`에서 끝냅니다. OWNER가 canonical product repository에서 plain `$sk-git`을 호출하면 local 변경 유무보다 먼저 `sk git preflight --cwd "$PWD" --json`을 실행하고 현재 저장소의 허용된 contributor PR을 자동 발견해 remote diff를 검토한 뒤 순차 squash merge합니다. 결과에는 `PR 처리: 0건 | merged | held | pending` receipt가 반드시 남습니다. repository 이전 전 `Seokang/<repo>` remote도 GitHub canonical `full_name`이 정확히 `selink-lab/<허용 repo>`일 때만 같은 원본으로 인정합니다. 특정 PR 하나만 처리하려면 `$sk-git PR #<number> 병합`을 사용합니다. 친구는 personal fork에서 commit/push/PR까지만 수행하고, merge 뒤 다음 `$sk-git`/feature/bugfix 시작 시 clean/ff-only 조건에서 원본 최신 main을 local default branch에 반영합니다. `sk update`는 제품 코드 pull이 아니라 공용 skill 업데이트에만 사용합니다.
+
+`$sk-git`과 `$sk-deploy`를 함께 호출하면 PR scan과 candidate별 merged/held 결과를 먼저 확정하고 canonical main을 fast-forward한 뒤 배포합니다. `$sk-deploy`만 호출한 경우에는 PR 또는 GitHub 사용자 확인을 배포 gate로 추가하지 않습니다.
 
 모든 배포 스크립트는 build/upload/restart/publish 전에 DB execution boundary를 확인합니다. OWNER/NON_OWNER/root/seokang 같은 사용자 유형은 판정하지 않으며, local config의 SSH/npm/API/CDN credential로 실제 명령을 실행한 결과만 사용합니다.
 

package/docs/policies/context-and-track.md

@@ -40,7 +40,7 @@
 
 #### Canonical origin 시작 순서
 
-1. `origin=github.com/selink-lab/<repo>`이고 확인한 repository name과 일치하는지 먼저 검증한다. 개인 fork나 다른 host의 origin이면 fetch/merge하지 않는다.
+1. `origin=github.com/selink-lab/<repo>`이고 확인한 repository name과 일치하는지 먼저 검증한다. repository transfer 전 `github.com/Seokang/<repo>` 주소가 남아 있으면 GitHub API의 canonical `full_name`이 정확히 `selink-lab/<허용 repo>`인지 확인한 경우에만 같은 원본으로 인정하며 local remote URL은 자동 변경하지 않는다. 개인 fork나 다른 host의 origin이면 fetch/merge하지 않는다.
 2. 새 작업 전에 원본의 열린 PR을 최대 100건 조회한다.
    - `gh pr list --repo selink-lab/<repo> --state open --limit 100 --json number,title,author,headRefName,baseRefName,url,reviewDecision`
 3. 열린 PR이 현재 요청과 같은 파일/도메인에 영향을 줄 수 있으면 PR diff와 checks를 먼저 읽고 새 작업과의 충돌 여부를 보고한다. 일반 작업 bootstrap은 PR을 merge/close하지 않는다. 단, OWNER가 현재 canonical product repository에서 plain `$sk-git`을 호출하면 현재 저장소의 허용된 contributor PR을 발견·검토·순차 squash merge하고, `$sk-git PR #<number> 병합`은 지정 PR 하나만 처리한다. 두 경로 모두 GitHub Free protection 미지원/check 완전 부재를 검토 위험으로 공개하고 나머지 CI/head/main 안전조건을 재검증한다.

package/docs/policies/core-safety.md

@@ -100,6 +100,8 @@
   - OWNER + canonical origin: `main`/`master`에 직접 push 가능
   - NON_OWNER + 개인 fork origin + `selink-lab` upstream: 개인 fork 작업 branch push 후 upstream PR
 - PR merge는 OWNER가 현재 canonical repository에서 plain `$sk-git` 또는 `$sk-git PR #<number> 병합`을 호출한 턴에만 실행한다. plain 호출은 현재 저장소의 허용된 contributor PR을 발견·검토·순차 squash merge하고, 번호 지정 호출은 해당 PR 하나만 처리한다. 예약 자동 병합, 다른 저장소 일괄 조회/병합, NON_OWNER merge는 금지하며 GitHub OWNER credential과 ACL을 다시 확인한다.
+- plain `$sk-git`은 local 변경 유무를 보기 전에 `sk git preflight --cwd "$PWD" --json`을 실행하고 PR scan receipt를 남긴다. 이전 개인 주소가 GitHub repository transfer redirect로 정확히 `selink-lab/<허용 repo>`에 resolve될 때만 canonical origin으로 인정하며 local remote URL은 자동 변경하지 않는다.
+- `$sk-git`과 `$sk-deploy`가 같은 요청에 있으면 PR scan과 candidate별 merged/held 결과를 먼저 확정하고 canonical main을 fast-forward한 뒤 deploy를 시작한다. deploy 단독 호출에는 GitHub PR/identity gate를 추가하지 않는다.
 - NON_OWNER의 `$sk-git`은 clean 상태에서만 개인 fork `origin` + `selink-lab` `upstream` topology를 확인하고, 병합 완료된 작업 branch 또는 local default branch를 `upstream/<default>`에 `--ff-only`로 맞춘다. reset/rebase/force push와 fork default push는 하지 않는다.
 - `$sk-git`과 `sk guard git`은 로컬 `gh` session으로 OWNER를 재판정하지 않는다. canonical `main`/`master` push는 GitHub ACL이 OWNER credential만 승인하고, NON_OWNER는 개인 fork PR로 요청한다.
 - 사용자가 `$sk-git`을 호출한 것은 현재 변경을 분석하고 허용된 경로로 add → commit → push하라는 명시적 실행 승인이다. OWNER canonical origin의 `main`/`master` push가 local guard에서 ALLOW이고 secret/stage hard-fail을 모두 통과하면, agent는 같은 push를 위해 두 번째 자연어 승인 문구를 요구하지 않는다.

package/docs/setup/fork-contributor-guide.md

@@ -145,7 +145,7 @@ git switch -c feature/<다음-작업명>
 
 충돌이 있으면 `main`에 임의 merge commit을 만들거나 force push하지 말고 SeoKang에게 전달한다.
 
-`$sk-git`은 이 과정을 `node ~/.agents/skills/scripts/git_fork_sync.mjs --cwd "$PWD" --json`으로 실행한다. worktree/index가 dirty하거나 local default가 ahead/diverged이면 fetch/switch/merge를 실행하지 않는다. 작업 branch의 PR이 아직 OPEN이면 현재 branch를 유지하고, MERGED일 때만 local default로 이동한다.
+`$sk-git`은 첫 단계에서 `sk git preflight --cwd "$PWD" --json`을 실행한다. 개인 fork에서는 receipt가 `route=contributor-fork`, `pr_scan=not-applicable`로 나오며 OWNER PR merge를 시도하지 않는다. 이어서 `node ~/.agents/skills/scripts/git_fork_sync.mjs --cwd "$PWD" --json`으로 동기화한다. worktree/index가 dirty하거나 local default가 ahead/diverged이면 fetch/switch/merge를 실행하지 않는다. 작업 branch의 PR이 아직 OPEN이면 현재 branch를 유지하고, MERGED일 때만 local default로 이동한다.
 
 ## 7-1. 공용 스킬 업데이트
 

package/docs/setup/sk-cli-guide.md

@@ -285,10 +285,13 @@ sk guard db-execution
 Git write는 identity가 아니라 현재 branch와 remote topology를 검사한다.
 
 ```bash
+sk git preflight --cwd "$PWD" --json
 sk guard git --action push --branch codex/my-feature --repo price-advisor-spinks
 sk guard git --action tag --branch main --repo seokang-codex-setting
 ```
 
+- plain `$sk-git`은 첫 명령의 receipt로 OWNER canonical 저장소의 PR scan 실행 여부와 `none|review-required|pending` 상태를 남긴다. local tracked 변경이 없어도 이 단계는 생략하지 않는다.
+- repository 이전 전 `Seokang/<repo>` origin은 GitHub API가 exact `selink-lab/<허용 repo>` canonical `full_name`을 반환할 때만 OWNER PR 경로로 해석한다. local remote는 자동 수정하지 않는다.
 - 개인 fork 작업자는 remote URL에서 확인한 `<fork-owner>`의 작업 branch를 `origin`에 push하고 `selink-lab` 원본 `upstream`으로 PR을 만든다.
 - 일반 작업 branch와 `main`/`master` guard는 GitHub identity/cache를 사용하지 않는다. OWNER는 canonical main에 직접 push하고, NON_OWNER는 개인 fork 작업 branch와 PR까지만 진행하며 실제 구분은 GitHub ACL이 담당한다.
 - push 인증/network 실패가 나도 local commit은 보존하고 `push pending`으로 보고한다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seokang-sk",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "SeoKang Codex 공용 설정과 스킬을 설치하는 CLI",
   "license": "MIT",
   "homepage": "https://github.com/selink-lab/seokang-codex-setting",

package/scripts/check_automation_safety.mjs

@@ -82,10 +82,14 @@ const STATIC_CHECKS = [
       "'--match-head-commit'",
       "'--merge'",
       "'--inspect-open-current'",
+      "'--preflight-current'",
       'listOpenPullRequests',
       '명시적인 --merge',
       'ownerIds',
-      'inspectCurrentRepository',
+      'ownerLogins',
+      'resolveCurrentRepository',
+      'GIT_CANONICAL_REDIRECT_UNTRUSTED',
+      "command: 'sk git preflight'",
       'HEAD_SHA_CHANGED',
       'MAIN_SHA_CHANGED',
       'POST_MERGE_STATE_UNVERIFIED',

package/scripts/check_docs_integrity.mjs

@@ -139,7 +139,7 @@ const REQUIRED_POLICY_FILES = [
       },
       {
         label: 'git owner merge and contributor sync',
-        fragments: ['NON_OWNER Upstream Sync', 'git_fork_sync.mjs', 'OWNER Current-Repository PR Merge', 'git_pr_merge.mjs', '--inspect-open-current', 'plain `$sk-git`', '--match-head-commit'],
+        fragments: ['Executable Git Workflow Preflight Receipt', 'sk git preflight', 'receipt', 'NON_OWNER Upstream Sync', 'git_fork_sync.mjs', 'OWNER Current-Repository PR Merge', 'git_pr_merge.mjs', 'plain `$sk-git`', '--match-head-commit'],
       },
       {
         label: 'git secret hard-fail',

package/scripts/check_fork_contribution.mjs

@@ -88,7 +88,8 @@ requireFragments('sk-git', gitSkill, [
   'seokang-codex-setting',
   'git_fork_sync.mjs',
   'git_pr_merge.mjs',
-  '--inspect-open-current',
+  'sk git preflight',
+  'receipt',
   'plain `$sk-git`',
   'OWNER Current-Repository PR Merge',
 ]);
@@ -104,6 +105,8 @@ requireFragments('core-safety', coreSafety, [
   'Codex, 로컬 테스트, CI, deploy, start/restart script',
   'Repository Access Matrix',
   'Git Secret Hard-Fail',
+  'sk git preflight',
+  'PR scan receipt',
 ]);
 
 const guide = await read('docs/setup/fork-contributor-guide.md');

package/scripts/check_git_pr_merge_integration.mjs

@@ -9,14 +9,22 @@ import { fileURLToPath } from 'node:url';
 
 const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const HELPER = path.join(REPO_ROOT, 'scripts', 'git_pr_merge.mjs');
+const SK_SCRIPT = path.join(REPO_ROOT, 'scripts', 'sk.mjs');
 const tempRoot = await mkdtemp(path.join(os.tmpdir(), 'git-pr-merge-'));
 
 const fakeGit = `#!/usr/bin/env node
+const { appendFileSync } = require('node:fs');
 const args = process.argv.slice(2);
+if (process.env.FAKE_GIT_TRACE) appendFileSync(process.env.FAKE_GIT_TRACE, args.join(' ') + '\\n');
 if (args.join(' ') === 'remote get-url origin') {
   process.stdout.write(process.env.FAKE_ORIGIN || 'git@github.com:selink-lab/slk-api.git');
   process.exit(0);
 }
+if (args.join(' ') === 'remote get-url upstream' && process.env.FAKE_UPSTREAM) {
+  process.stdout.write(process.env.FAKE_UPSTREAM);
+  process.exit(0);
+}
+if (args.join(' ') === 'status --porcelain') process.exit(0);
 process.stderr.write('unexpected fake git args: ' + args.join(' '));
 process.exit(2);
 `;
@@ -25,6 +33,7 @@ const fakeGh = `#!/usr/bin/env node
 import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
 const args = process.argv.slice(2);
 const output = (value) => process.stdout.write(JSON.stringify(value));
+if (process.env.FAKE_GH_TRACE) appendFileSync(process.env.FAKE_GH_TRACE, args.join(' ') + '\\n');
 if (args[0] === 'api') {
   const endpoint = args[1];
   if (endpoint === 'user') {
@@ -34,6 +43,9 @@ if (args[0] === 'api') {
     }
     output({ id: Number(process.env.FAKE_USER_ID || '48157145'), login: process.env.FAKE_LOGIN || 'Seokang' });
   }
+  else if (/^repos\\/[^/]+\\/[^/]+$/.test(endpoint)) {
+    output({ full_name: process.env.FAKE_CANONICAL_REPOSITORY || endpoint.slice('repos/'.length), default_branch: 'main' });
+  }
   else if (endpoint.endsWith('/protection')) {
     if (process.env.FAKE_PROTECTION_UNSAFE) {
       output({ required_status_checks: { strict: false, contexts: [], checks: [] }, enforce_admins: { enabled: false } });
@@ -104,6 +116,14 @@ function inspect(extraEnv = {}) {
   });
 }
 
+function preflight(extraEnv = {}) {
+  return spawnSync(process.execPath, [SK_SCRIPT, 'git', 'preflight', '--cwd', tempRoot, '--json'], {
+    cwd: REPO_ROOT,
+    encoding: 'utf8',
+    env: { ...process.env, PATH: `${tempRoot}:${process.env.PATH}`, SK_DISABLE_FORWARD: '1', SK_REPO_ROOT: REPO_ROOT, ...extraEnv },
+  });
+}
+
 try {
   const ghPath = path.join(tempRoot, 'gh');
   const gitPath = path.join(tempRoot, 'git');
@@ -125,6 +145,50 @@ try {
   assert.deepEqual(openResult.pullRequests.map((pr) => pr.target), ['selink-lab/slk-api#1']);
   assert.deepEqual(openResult.pullRequests[0].files, ['docs/guide.md']);
   assert.equal(openResult.ignored[0].reason, 'AUTHOR_NOT_ALLOWED');
+  assert.equal(openResult.receipt.pr_scan, 'executed');
+  assert.equal(openResult.receipt.open_count, 2);
+
+  const gitTrace = path.join(tempRoot, 'git-preflight.trace');
+  const ghTrace = path.join(tempRoot, 'gh-preflight.trace');
+  const cleanPreflight = preflight({ FAKE_GH_LOG: mergeLog, FAKE_GIT_TRACE: gitTrace, FAKE_GH_TRACE: ghTrace });
+  assert.equal(cleanPreflight.status, 0, cleanPreflight.stderr || cleanPreflight.stdout);
+  const cleanReceipt = JSON.parse(cleanPreflight.stdout).receipt;
+  assert.equal(cleanReceipt.executed, true);
+  assert.equal(cleanReceipt.route, 'owner-pr');
+  assert.equal(cleanReceipt.pr_scan, 'executed');
+  assert.deepEqual(cleanReceipt.candidate_count, 1);
+  assert.match(await readFile(ghTrace, 'utf8'), /pr list --repo selink-lab\/slk-api/);
+  assert.doesNotMatch(await readFile(ghTrace, 'utf8'), /pr merge/);
+  assert.doesNotMatch(await readFile(gitTrace, 'utf8'), /commit|push/);
+
+  const redirectedPreflight = preflight({
+    FAKE_GH_LOG: mergeLog,
+    FAKE_ORIGIN: 'https://github.com/Seokang/slk-api.git',
+    FAKE_UPSTREAM: 'git@github.com:selink-lab/slk-api.git',
+    FAKE_CANONICAL_REPOSITORY: 'selink-lab/slk-api',
+  });
+  assert.equal(redirectedPreflight.status, 0, redirectedPreflight.stderr || redirectedPreflight.stdout);
+  const redirectedReceipt = JSON.parse(redirectedPreflight.stdout).receipt;
+  assert.equal(redirectedReceipt.origin_repository, 'Seokang/slk-api');
+  assert.equal(redirectedReceipt.canonical_repository, 'selink-lab/slk-api');
+  assert.equal(redirectedReceipt.redirected, true);
+  assert.equal(redirectedReceipt.route, 'owner-pr');
+
+  const contributorPreflight = preflight({
+    FAKE_ORIGIN: 'git@github.com:91kwangmin/slk-api.git',
+    FAKE_UPSTREAM: 'git@github.com:selink-lab/slk-api.git',
+  });
+  assert.equal(contributorPreflight.status, 0, contributorPreflight.stderr || contributorPreflight.stdout);
+  const contributorReceipt = JSON.parse(contributorPreflight.stdout).receipt;
+  assert.equal(contributorReceipt.route, 'contributor-fork');
+  assert.equal(contributorReceipt.pr_scan, 'not-applicable');
+
+  const untrustedRedirect = preflight({
+    FAKE_ORIGIN: 'git@github.com:outsider/slk-api.git',
+    FAKE_CANONICAL_REPOSITORY: 'outsider/slk-api',
+  });
+  assert.equal(untrustedRedirect.status, 1, untrustedRedirect.stderr || untrustedRedirect.stdout);
+  assert.equal(JSON.parse(untrustedRedirect.stdout).error.code, 'GIT_CANONICAL_REDIRECT_UNTRUSTED');
 
   const multipleInspection = inspect({ FAKE_GH_LOG: mergeLog, FAKE_MULTIPLE_PRS: '1' });
   assert.equal(multipleInspection.status, 0, multipleInspection.stderr || multipleInspection.stdout);
@@ -136,7 +200,7 @@ try {
 
   const nonOwner = run({ FAKE_GH_LOG: mergeLog, FAKE_USER_ID: '999', FAKE_LOGIN: 'friend' });
   assert.equal(nonOwner.status, 1, nonOwner.stderr || nonOwner.stdout);
-  assert.equal(JSON.parse(nonOwner.stdout).error.code, 'GIT_PR_MERGE_FAILED');
+  assert.equal(JSON.parse(nonOwner.stdout).error.code, 'OWNER_REQUIRED');
 
   const nonOwnerInspection = inspect({ FAKE_GH_LOG: mergeLog, FAKE_USER_ID: '999', FAKE_LOGIN: 'friend' });
   assert.equal(nonOwnerInspection.status, 1, nonOwnerInspection.stderr || nonOwnerInspection.stdout);

package/scripts/check_sk_cli_smoke.mjs

@@ -160,6 +160,7 @@ console.log(JSON.stringify({ id, login: mode === 'owner-renamed' ? 'renamed-owne
   assertIncludes(runSk(['help'], env, 'sk help'), 'sk create', 'sk help');
   assertIncludes(runSk(['help'], env, 'sk help'), 'sk update', 'sk help');
   assertIncludes(runSk(['help'], env, 'sk help'), 'sk style', 'sk help');
+  assertIncludes(runSk(['help'], env, 'sk help'), 'sk git preflight', 'sk help');
   assertIncludes(runSk(['help'], env, 'sk help'), 'sk identity status', 'sk help');
   assertIncludes(runSk(['help'], env, 'sk help'), 'sk guard implementation --db-impact', 'sk help');
   assertIncludes(runSk(['help'], env, 'sk help'), 'sk guard db-execution', 'sk help');
@@ -173,6 +174,7 @@ console.log(JSON.stringify({ id, login: mode === 'owner-renamed' ? 'renamed-owne
   assertIncludes(runSk(['help', 'guard'], env, 'sk help guard'), '--isolated', 'sk help guard');
   assertIncludes(runSk(['help', 'guard'], env, 'sk help guard'), '--staged', 'sk help guard');
   assertIncludes(runSk(['help', 'guard'], env, 'sk help guard'), '--outbound', 'sk help guard');
+  assertIncludes(runSk(['help', 'git'], env, 'sk help git'), 'receipt', 'sk help git');
 
   const secretGuardRoot = path.join(tempRoot, 'secret-guard-project');
   const secretGuardOrigin = path.join(tempRoot, 'secret-guard-origin.git');

package/scripts/git_pr_merge.mjs

@@ -18,23 +18,25 @@ class GitPrMergeError extends Error {
 }
 
 function usage() {
-  console.log('Usage: node scripts/git_pr_merge.mjs (--inspect-open-current | --merge <owner/repo>#<number>) [--cwd <path>] [--json]');
+  console.log('Usage: node scripts/git_pr_merge.mjs (--preflight-current | --inspect-open-current | --merge <owner/repo>#<number>) [--cwd <path>] [--json]');
   console.log('$sk-git에서 현재 canonical repository의 열린 PR을 확인하거나 OWNER가 검토한 PR 하나를 squash merge합니다.');
 }
 
 function parseArgs(argv) {
-  const options = { cwd: process.cwd(), json: false, inspectOpenCurrent: false, merge: null };
+  const options = { cwd: process.cwd(), json: false, preflightCurrent: false, inspectOpenCurrent: false, merge: null };
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === '--help' || arg === '-h') return { ...options, help: true };
     if (arg === '--json') options.json = true;
+    else if (arg === '--preflight-current') options.preflightCurrent = true;
     else if (arg === '--inspect-open-current') options.inspectOpenCurrent = true;
     else if (arg === '--merge') options.merge = argv[++index];
     else if (arg === '--cwd') options.cwd = path.resolve(argv[++index]);
     else throw new Error(`지원하지 않는 옵션: ${arg}`);
   }
-  if (options.inspectOpenCurrent === Boolean(options.merge)) {
-    throw new Error('--inspect-open-current 또는 --merge <owner/repo>#<number> 중 하나가 필요합니다.');
+  const selectedModes = [options.preflightCurrent, options.inspectOpenCurrent, Boolean(options.merge)].filter(Boolean).length;
+  if (selectedModes !== 1) {
+    throw new Error('--preflight-current, --inspect-open-current, --merge <owner/repo>#<number> 중 하나가 필요합니다.');
   }
   if (options.merge && !/^[-\w]+\/[-\w.]+#\d+$/.test(options.merge)) {
     throw new Error('명시적인 --merge <owner/repo>#<number> 형식이 필요합니다.');
@@ -73,12 +75,14 @@ async function loadPolicy() {
   if (!Array.isArray(repositories) || repositories.length === 0) throw new Error('forkPr repository 정책이 비어 있습니다.');
   if (!Array.isArray(prMerge?.allowedAuthors) || prMerge.allowedAuthors.length === 0) throw new Error('PR merge allowedAuthors 정책이 비어 있습니다.');
   return {
+    githubHost: document.githubHost,
     organization: prMerge.organization,
     allowedAuthors: prMerge.allowedAuthors,
     repositories,
     strategy: prMerge.strategy,
     requiredCheckNames: prMerge.requiredCheckNames,
     ownerIds: (document.owners || []).map((owner) => Number(owner.githubUserId)).filter(Number.isInteger),
+    ownerLogins: (document.owners || []).map((owner) => String(owner.githubLogin || '').toLowerCase()).filter(Boolean),
   };
 }
 
@@ -168,23 +172,73 @@ function parseGitHubRemote(remote) {
   return match ? `${match[1]}/${match[2]}` : null;
 }
 
-function inspectCurrentRepository(cwd) {
-  const result = spawnSync('git', ['remote', 'get-url', 'origin'], { cwd, encoding: 'utf8' });
-  if (result.error || result.status !== 0) throw new Error('현재 repository의 origin을 확인할 수 없습니다.');
-  return parseGitHubRemote(result.stdout);
+function inspectRemote(cwd, name, required = true) {
+  const result = spawnSync('git', ['remote', 'get-url', name], { cwd, encoding: 'utf8' });
+  if (result.error || result.status !== 0) {
+    if (!required) return null;
+    throw new GitPrMergeError('GIT_REMOTE_UNAVAILABLE', `${name} remote 확인`);
+  }
+  const repository = parseGitHubRemote(result.stdout);
+  if (!repository) {
+    if (!required) return null;
+    throw new GitPrMergeError('GIT_REMOTE_UNSUPPORTED', `${name} GitHub repository 확인`);
+  }
+  return repository;
 }
 
-function resolveCurrentRepository(policy, cwd) {
-  const currentRepository = inspectCurrentRepository(cwd);
-  const allowedRepositories = new Set(policy.repositories.map((name) => `${policy.organization}/${name}`.toLowerCase()));
-  if (!currentRepository || !allowedRepositories.has(currentRepository.toLowerCase())) {
-    throw new Error(`현재 canonical repository는 PR 처리 허용 대상이 아닙니다: ${currentRepository || 'unknown'}`);
+function canonicalRepository(policy, repository) {
+  return policy.repositories
+    .map((name) => `${policy.organization}/${name}`)
+    .find((candidate) => candidate.toLowerCase() === String(repository || '').toLowerCase()) || null;
+}
+
+function resolveCurrentRepository(policy, cwd, currentRepository = inspectRemote(cwd, 'origin')) {
+  const direct = canonicalRepository(policy, currentRepository);
+  if (direct) {
+    return { repository: direct, originRepository: currentRepository, redirected: false };
   }
-  return currentRepository;
+
+  const metadata = ghJson(['api', `repos/${currentRepository}`], `${currentRepository} canonical repository 확인`);
+  const resolved = canonicalRepository(policy, metadata?.full_name);
+  if (!resolved) {
+    throw new GitPrMergeError('GIT_CANONICAL_REDIRECT_UNTRUSTED', `${currentRepository} canonical repository 확인`);
+  }
+  return { repository: resolved, originRepository: currentRepository, redirected: resolved.toLowerCase() !== currentRepository.toLowerCase() };
 }
 
-function inspectOpenCurrent(policy, cwd) {
-  const repository = resolveCurrentRepository(policy, cwd);
+function resolvePreflightRoute(policy, cwd) {
+  const originRepository = inspectRemote(cwd, 'origin');
+  const direct = canonicalRepository(policy, originRepository);
+  if (direct) {
+    return { route: 'owner-pr', resolution: { repository: direct, originRepository, redirected: false } };
+  }
+
+  const originOwner = originRepository.split('/')[0]?.toLowerCase();
+  if (policy.ownerLogins.includes(originOwner)) {
+    return { route: 'owner-pr', resolution: resolveCurrentRepository(policy, cwd, originRepository) };
+  }
+
+  const upstreamRepository = inspectRemote(cwd, 'upstream', false);
+  const upstreamCanonical = canonicalRepository(policy, upstreamRepository);
+  const originName = originRepository.split('/')[1]?.toLowerCase();
+  const upstreamName = upstreamRepository?.split('/')[1]?.toLowerCase();
+  if (upstreamCanonical && originName && originName === upstreamName) {
+    return { route: 'contributor-fork', originRepository, repository: upstreamCanonical };
+  }
+
+  return { route: 'owner-pr', resolution: resolveCurrentRepository(policy, cwd, originRepository) };
+}
+
+function requireOwnerCredential(policy) {
+  const identity = ghJson(['api', 'user'], 'GitHub OWNER credential 확인');
+  if (!policy.ownerIds.includes(Number(identity?.id))) {
+    throw new GitPrMergeError('OWNER_REQUIRED', 'GitHub OWNER credential 확인');
+  }
+  return identity;
+}
+
+function inspectOpenCurrent(policy, cwd, resolution = resolveCurrentRepository(policy, cwd)) {
+  const repository = resolution.repository;
   const repositoryState = inspectRepository(repository, policy.requiredCheckNames);
   const repositoryPolicy = { ...policy, trustedRepository: repository };
   const evaluationOptions = {
@@ -222,26 +276,85 @@ function inspectOpenCurrent(policy, cwd) {
 
   return {
     repository,
+    originRepository: resolution.originRepository,
+    redirected: resolution.redirected,
     defaultBranch: repositoryState.defaultBranch,
     mainSha: repositoryState.mainSha,
     status: pullRequests.length > 0 ? 'review-required' : 'none',
+    openCount: openPullRequests.length,
     pullRequests,
     ignored,
   };
 }
 
+function withPreflightReceipt(result) {
+  return {
+    ...result,
+    receipt: {
+      schema_version: 1,
+      command: 'sk git preflight',
+      executed: true,
+      route: 'owner-pr',
+      pr_scan: 'executed',
+      status: result.status,
+      origin_repository: result.originRepository,
+      canonical_repository: result.repository,
+      redirected: result.redirected,
+      open_count: result.openCount,
+      candidate_count: result.pullRequests.length,
+      ignored_count: result.ignored.length,
+    },
+  };
+}
+
+function contributorPreflightReceipt(route) {
+  return {
+    status: 'not-applicable',
+    repository: route.repository,
+    originRepository: route.originRepository,
+    receipt: {
+      schema_version: 1,
+      command: 'sk git preflight',
+      executed: true,
+      route: 'contributor-fork',
+      pr_scan: 'not-applicable',
+      status: 'not-applicable',
+      origin_repository: route.originRepository,
+      canonical_repository: route.repository,
+      redirected: false,
+      open_count: null,
+      candidate_count: null,
+      ignored_count: null,
+    },
+  };
+}
+
+function mergeReceipt(status, repository, currentRepository, number) {
+  return {
+    schema_version: 1,
+    command: 'sk git merge',
+    executed: true,
+    route: 'owner-pr',
+    status,
+    origin_repository: currentRepository.originRepository,
+    canonical_repository: repository,
+    redirected: currentRepository.redirected,
+    pr_number: Number(number),
+  };
+}
+
 function runExplicitMerge(target, policy, cwd) {
   const [repository, numberText] = target.split('#');
-  const allowedRepositories = new Set(policy.repositories.map((name) => `${policy.organization}/${name}`));
-  if (!allowedRepositories.has(repository)) throw new Error(`병합 허용 대상이 아닌 repository: ${repository}`);
-  const currentRepository = inspectCurrentRepository(cwd);
-  if (currentRepository?.toLowerCase() !== repository.toLowerCase()) {
-    throw new Error(`현재 canonical repository와 PR 대상이 다릅니다: ${currentRepository || 'unknown'} != ${repository}`);
+  const allowedRepository = canonicalRepository(policy, repository);
+  if (!allowedRepository) throw new GitPrMergeError('PR_REPOSITORY_NOT_ALLOWED', `${repository} PR merge 대상 확인`);
+  const currentRepository = resolveCurrentRepository(policy, cwd);
+  if (currentRepository.repository.toLowerCase() !== allowedRepository.toLowerCase()) {
+    throw new GitPrMergeError('CURRENT_REPOSITORY_MISMATCH', `${currentRepository.repository} != ${allowedRepository}`);
   }
 
-  const repositoryState = inspectRepository(repository, policy.requiredCheckNames);
-  const pr = inspectPullRequest(repository, Number(numberText));
-  const repositoryPolicy = { ...policy, trustedRepository: repository };
+  const repositoryState = inspectRepository(allowedRepository, policy.requiredCheckNames);
+  const pr = inspectPullRequest(allowedRepository, Number(numberText));
+  const repositoryPolicy = { ...policy, trustedRepository: allowedRepository };
   const evaluationOptions = {
     allowedRiskLevels: ['low', 'medium', 'high'],
     allowReviewRequired: true,
@@ -250,11 +363,24 @@ function runExplicitMerge(target, policy, cwd) {
   };
   const evaluation = evaluatePullRequest(pr, repositoryPolicy, repositoryState, evaluationOptions);
   if (!evaluation.eligible) {
-    return { target, status: 'held', url: pr.url, evaluation };
+    return {
+      target: `${allowedRepository}#${numberText}`,
+      status: 'held',
+      url: pr.url,
+      evaluation,
+      receipt: mergeReceipt('held', allowedRepository, currentRepository, numberText),
+    };
   }
 
-  const mergeResult = revalidateAndMerge(repository, pr, repositoryPolicy, repositoryState, evaluationOptions);
-  return { target, status: mergeResult.status, url: pr.url, evaluation, mergeResult };
+  const mergeResult = revalidateAndMerge(allowedRepository, pr, repositoryPolicy, repositoryState, evaluationOptions);
+  return {
+    target: `${allowedRepository}#${numberText}`,
+    status: mergeResult.status,
+    url: pr.url,
+    evaluation,
+    mergeResult,
+    receipt: mergeReceipt(mergeResult.status, allowedRepository, currentRepository, numberText),
+  };
 }
 
 async function main() {
@@ -262,17 +388,27 @@ async function main() {
   if (options.help) return usage();
 
   const policy = await loadPolicy();
-  if (!policy.organization || policy.strategy !== 'squash') throw new Error('지원하지 않는 PR merge 정책입니다.');
-  const identity = ghJson(['api', 'user'], 'GitHub OWNER credential 확인');
-  if (!policy.ownerIds.includes(Number(identity?.id))) throw new Error(`OWNER 계정이 아니므로 PR 병합을 실행하지 않습니다: ${identity?.login || 'unknown'}`);
+  if (!policy.githubHost || !policy.organization || policy.strategy !== 'squash') throw new Error('지원하지 않는 PR merge 정책입니다.');
 
-  const result = options.inspectOpenCurrent
-    ? inspectOpenCurrent(policy, options.cwd)
-    : runExplicitMerge(options.merge, policy, options.cwd);
+  let result;
+  if (options.preflightCurrent) {
+    const route = resolvePreflightRoute(policy, options.cwd);
+    if (route.route === 'contributor-fork') {
+      result = contributorPreflightReceipt(route);
+    } else {
+      requireOwnerCredential(policy);
+      result = withPreflightReceipt(inspectOpenCurrent(policy, options.cwd, route.resolution));
+    }
+  } else {
+    requireOwnerCredential(policy);
+    result = options.inspectOpenCurrent
+      ? withPreflightReceipt(inspectOpenCurrent(policy, options.cwd))
+      : runExplicitMerge(options.merge, policy, options.cwd);
+  }
   if (options.json) console.log(JSON.stringify(result, null, 2));
-  else if (options.inspectOpenCurrent) console.log(`OWNER 현재 저장소 PR 확인: ${result.repository} ${result.status} (${result.pullRequests.length})`);
+  else if (options.preflightCurrent || options.inspectOpenCurrent) console.log(`Git PR preflight: ${result.repository} ${result.status} (${result.pullRequests?.length || 0})`);
   else console.log(`OWNER PR merge: ${result.target} ${result.status} ${result.url}`);
-  if (!options.inspectOpenCurrent && result.status !== 'merged') process.exitCode = 2;
+  if (!options.preflightCurrent && !options.inspectOpenCurrent && result.status !== 'merged') process.exitCode = 2;
 }
 
 main().catch((error) => {

package/scripts/sk.mjs

@@ -768,6 +768,7 @@ function generalHelpLines() {
     { name: 'sk style', description: '기존 프로젝트 profile audit/apply' },
     { name: 'sk check', description: '설치 결과와 공용 원본의 차이 점검' },
     { name: 'sk status', description: '현재 프로젝트 상태와 최근 백업 확인' },
+    { name: 'sk git preflight', description: 'plain $sk-git의 현재 저장소 PR 확인 receipt 생성' },
     { name: 'sk identity status', description: '선택적 GitHub operator 진단 정보 확인' },
     { name: 'sk guard implementation --db-impact', description: '호환용 명령: DB 코드 작성은 허용하고 실행 금지를 안내' },
     { name: 'sk guard db-execution', description: 'local test/CI/build 전 production DB 자동 실행 경계 검사' },
@@ -974,6 +975,21 @@ function commandHelpLines(command) {
         'sk status --json',
       ],
     },
+    git: {
+      title: 'sk git - Git workflow 실행형 preflight',
+      usage: 'sk git preflight [--cwd <path>] [--json]',
+      summary: [
+        'plain $sk-git의 첫 단계에서 현재 저장소의 PR 처리 경로를 확정합니다.',
+        'OWNER canonical 저장소는 local 변경 유무와 무관하게 열린 contributor PR을 조회하고 receipt를 반환합니다.',
+        '개인 fork는 OWNER PR scan을 실행하지 않고 기존 fork sync/PR 경로를 유지합니다.',
+      ],
+      options: [
+        { flag: 'preflight', description: '현재 저장소의 Git PR 처리 경로와 열린 PR receipt 생성' },
+        { flag: '--cwd <path>', description: '대상 제품 저장소 경로' },
+        { flag: '--json', description: '기계 판독 가능한 receipt JSON 출력' },
+      ],
+      examples: ['sk git preflight --json', 'sk git preflight --cwd /path/to/project --json'],
+    },
     identity: {
       title: 'sk identity - 선택적 operator 진단',
       usage: 'sk identity status [--json]',
@@ -1081,6 +1097,7 @@ function commandHelpLines(command) {
       '  sk help style',
       '  sk help check',
       '  sk help status',
+      '  sk help git',
       '  sk help identity',
       '  sk help guard',
       '  sk help memory',
@@ -4408,6 +4425,23 @@ async function runGuard(flags, rest) {
   if (payload.decision !== ACCESS_DECISION.ALLOW) process.exitCode = 2;
 }
 
+async function runGitWorkflow(flags, rest) {
+  const subcommand = rest[0] || '';
+  if (subcommand !== 'preflight' || rest.length !== 1) {
+    fail('사용법: sk git preflight [--cwd <path>] [--json]');
+  }
+  const cwd = resolve(String(flags.get('cwd') || process.cwd()));
+  const helperArgs = [
+    join(REPO_ROOT, 'scripts', 'git_pr_merge.mjs'),
+    '--preflight-current',
+    '--cwd', cwd,
+  ];
+  if (flags.get('json')) helperArgs.push('--json');
+  const result = spawnSync(process.execPath, helperArgs, { cwd, stdio: 'inherit' });
+  if (result.error) throw new Error(`Git workflow preflight 실행 실패: ${result.error.message}`);
+  if (result.status !== 0) process.exitCode = result.status ?? 1;
+}
+
 async function main() {
   const [command, ...args] = process.argv.slice(2);
   if (!command || command === '--help' || command === '-h') {
@@ -4489,6 +4523,16 @@ async function main() {
     return;
   }
 
+  if (command === 'git') {
+    const { flags, rest } = parseFlags(args);
+    if (flags.get('help')) {
+      printUsage('git');
+      return;
+    }
+    await runGitWorkflow(flags, rest);
+    return;
+  }
+
   const { flags, rest } = parseFlags(args);
   if (flags.get('help')) {
     printUsage(command);