seokang-sk 0.7.0 → 0.7.2

package/README.MD

@@ -262,12 +262,12 @@ Windows Git Bash에서는 사용자 경로에 맞춰 `cd /c/Users/<user>/.agents
 - `sk status --cwd /path/to/project`: 다른 프로젝트 상태 확인
 - `sk identity status`: 선택적 GitHub operator 진단 정보 확인
 - `sk guard implementation --db-impact`: 이전 버전 호환용 안내. DB 코드 작성은 허용하고 실행은 금지
-- `sk guard db-execution`: local test/CI/build/deploy 전에 production DB 자동 실행 경로 검사
+- `sk guard db-execution`: local test/CI/일반 build 전에 production DB 자동 실행 경로를 strict 검사. `$sk-deploy`는 내부 deploy-packaging mode로 실행되지 않는 DB test source를 허용하고 실제 test/migration 실행만 차단
 - `sk guard git --action push --branch <name> --repo <name>`: OWNER main push와 NON_OWNER 작업 branch/PR 경계 확인
 - `sk guard stage pre-add|pre-commit <path ...>`: intended commit path와 Git index 일치 검사
 - `sk guard secrets --worktree` / `--staged` / `--outbound --remote origin`: add, commit, push 직전 secret hard-fail
 - `sk guard deploy --environment <name> --artifact <type> --action <action> --db-impact-status <status>`: 배포 credential 및 DB 무실행 경계 안내
-- 구현/commit/작업 branch는 identity 확인이나 cache를 요구하지 않는다. OWNER의 canonical `main`/`master` 직접 push와 배포는 GitHub ACL·OWNER credential을 실제 경계로 사용하고, NON_OWNER는 개인 fork PR까지만 진행한다.
+- 구현/commit/작업 branch는 identity 확인이나 cache를 요구하지 않는다. OWNER의 canonical `main`/`master` 직접 push는 GitHub ACL을 사용하고, 배포는 사용자 유형이 아니라 local credential과 원격 권한으로 실행한다. NON_OWNER Git 작업은 개인 fork PR까지만 진행한다.
 - [상세 CLI 가이드](docs/setup/sk-cli-guide.md)를 기준 문서로 사용
 
 ---
@@ -418,11 +418,15 @@ 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까지만 허용
 
-모든 배포 스크립트는 build/upload/restart/publish 전에 `sk guard deploy`와 DB execution boundary를 확인합니다. 실제 배포는 OWNER만 보유한 SSH/npm/API/CDN credential이 있어야 진행되며 GitHub session은 권한 근거로 쓰지 않습니다.
+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로 실제 명령을 실행한 결과만 사용합니다.
 
 별도 테스트/개발/로컬 DB는 없습니다. DB 코드·SQL·migration 파일은 작성하고 PR로 검토할 수 있지만 Codex, local test, CI, deploy, start/restart script는 migration/DDL/DML/backfill/seed를 실행하지 않습니다. 실제 반영은 OWNER 사용자가 별도 IDE/DB 도구에서 수동 실행합니다.
 
-이 로컬 guard는 실수 방지층입니다. GitHub Free private 저장소의 실제 차단은 `selink-lab` 원본 Read 권한, 개인 private fork/PR, OWNER만 보유한 SSH/npm/DB/API/CDN credential로 구성합니다. fork PR Actions에는 write token, secrets, variables를 전달하지 않고 OWNER 승인 후 workflow를 실행합니다.
+이 로컬 guard는 실수 방지층입니다. GitHub Free private 저장소의 실제 Git 차단은 `selink-lab` 원본 Read 권한과 개인 private fork/PR로 구성합니다. 배포는 local config에 credential이 설정된 환경에서만 가능하며 fork PR Actions에는 write token, secrets, variables를 전달하지 않습니다.
 
 예시 설정 파일:
 

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

@@ -40,10 +40,10 @@
 
 #### 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를 먼저 읽고 새 작업과의 충돌 여부를 보고한다. 자동 merge/close는 하지 않는다.
+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 안전조건을 재검증한다.
 4. worktree가 clean하고 현재 branch가 원본 default branch일 때만 `git fetch origin --prune` 후 `git merge --ff-only origin/<default-branch>`로 동기화한다.
 5. merge 뒤 `git rev-list --left-right --count HEAD...origin/<default-branch>`가 정확히 `0 0`인지 확인한다. local default가 ahead/diverged면 reset/rebase하지 않고 중단한다.
 6. 다른 작업 branch에 있으면 원격 fetch와 비교까지만 수행하고 임의로 branch를 전환하지 않는다.
@@ -57,6 +57,8 @@
 5. 동기화된 default branch에서 허용 prefix의 새 작업 branch를 만든다. private fork 작업자는 fork의 default branch나 upstream에 push하지 않는다.
 6. fast-forward가 불가능하거나 conflict가 예상되면 merge commit, rebase, force push로 임의 해결하지 않고 OWNER에게 전달한다.
 
+OWNER가 원본 PR을 merge해도 친구의 fork default branch를 강제로 수정하지 않는다. 친구가 다음 `$sk-git`, `$sk-feature`, `$sk-bugfix`를 호출하면 clean default branch 또는 merge 완료된 작업 branch에서만 위 fast-forward 절차로 `upstream/<default-branch>`를 local default branch에 반영한다.
+
 - network/API 오류를 최신 상태로 간주하지 않는다. fetch/PR 조회가 실패해도 local edit/test/commit은 진행하고, remote sync/push/PR만 `pending`으로 남기며 실패 범위와 stale-base 위험을 밝힌다.
 
 ## 2. Track Mapping

package/docs/policies/core-safety.md

@@ -85,7 +85,8 @@
 - Codex, 로컬 테스트, CI, deploy, start/restart script는 schema/data 변경을 절대 실행하지 않는다.
 - 금지되는 자동 실행에는 migration CLI, seed/backfill, SQL client write 실행, Flyway/Liquibase startup migration, Hibernate DDL create/update, ORM synchronize가 포함된다.
 - DB 영향 코드 검증은 DB 연결 없이 compile/typecheck, mock 단위 테스트, SQL 정적 lint/comment 검토로 제한한다. Testcontainers나 임시 DB를 새로 가정하지 않는다.
-- local test/build를 실행하기 전과 CI workflow의 첫 검증 단계에서 `sk guard db-execution`을 통과해야 한다. CI에 이 단계가 없거나 DB credential marker가 있으면 실행하지 않는다.
+- local test와 test를 포함할 수 있는 일반 build 전, 그리고 CI workflow의 첫 검증 단계에서 strict `sk guard db-execution`을 통과해야 한다. CI에 이 단계가 없거나 DB credential marker가 있으면 실행하지 않는다.
+- `$sk-deploy`의 고정 no-test packaging은 deploy helper가 `check_db_execution_boundary.mjs --mode deploy-packaging`으로 검사한다. 이 모드에서는 DB 연결 test source의 존재만 허용하되 packaging/lifecycle이 test를 실행하거나 migration/DDL/DML/startup schema mutation 경로가 있으면 hard-fail한다.
 - fork PR workflow에는 production DB connection string, SSH/npm/API/CDN credential, write token, Actions secrets/variables를 전달하지 않는다.
 - 모든 deploy artifact는 literal key/value local config와 project/package root를 `scripts/check_db_execution_boundary.mjs`로 검사한다. migration framework가 있으면 production startup disable 근거를 확인하지 못한 상태로 배포하지 않는다.
 - 일반 애플리케이션 query/DML은 OWNER가 PR을 검토하고 배포한 뒤 production runtime에서만 동작한다. 로컬/CI 검증을 위해 production DB에 실행하지 않는다.
@@ -98,10 +99,17 @@
 - 일반 Git 흐름은 local remote topology와 실제 GitHub repository ACL로 판단한다.
   - 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를 위해 두 번째 자연어 승인 문구를 요구하지 않는다.
+- live Codex runtime의 sandbox/network 정책이 실제 tool approval을 요구하면 agent가 해당 push 명령에 대한 범위가 좁은 approval/escalation 요청을 즉시 호출한다. 사용자에게 “승인한다고 다시 말해 달라”고 요구하거나 GitHub 권한 문제로 바꾸어 설명하지 않는다.
 - tag/release와 canonical mutation은 GitHub ACL이 최종 승인한다. 배포를 유발하는 tag/release는 OWNER가 main 반영 후 수행한다.
 - GitHub CLI 인증이나 network가 없으면 local edit/test/commit을 중단하지 않는다. push/PR 조회·생성만 `push pending`으로 보존한다.
-- 배포 preflight는 GitHub actor/session을 조회하지 않는다. 실제 차단 경계는 OWNER만 보유한 SSH key, npm publish 권한, production API/CDN/DB credential과 원격 계정 권한이다.
+- 배포 preflight는 GitHub actor/session, OWNER/NON_OWNER, local user, process owner를 조회하거나 분류하지 않는다. local config의 SSH key, npm/API/CDN credential과 원격 시스템의 실제 명령 결과만 사용한다.
+- deploy helper와 `sk guard deploy`는 별도 restart wrapper, sudoers, 사용자 프로필을 실행 권한 gate로 요구하지 않는다.
 - server/front/npm deploy script는 credential/config 확인 실패 시 upload/restart/publish 전에 종료한다.
 - GitHub Free private 저장소에서는 원본 저장소의 contributor 권한을 Read로 유지하고 production credential을 제공하지 않는 것이 실제 보호 경계다.
 - Organization에서 private repository forking을 허용하되 fork PR Actions에는 write token, Actions secrets, variables를 전달하지 않는다. fork PR workflow는 OWNER 검토 후 실행한다.

package/docs/setup/codex-workflows.md

@@ -53,6 +53,14 @@ Automation은 아래를 고정한 뒤 만든다.
 - Archive condition: 보고할 내용이 없을 때 자동 archive할 조건을 적는다.
 - Safety: read-only 점검인지, file edit이 필요한지, worktree 격리가 필요한지 적는다.
 
+현재 공용 automation 기준:
+
+- `docs/automations/daily-thread-retrospective.md`: 일일 task 회고
+- `docs/automations/notion-outbox-publish.md`: Notion outbox publish
+- `docs/automations/server-log-check.md`: 서버 로그 점검
+
+반복 결과를 한 곳에 계속 쌓아야 하는 heartbeat는 일반 개발 채팅에 붙이지 않고 Automations 프로젝트의 전용 채팅을 먼저 만든 뒤 그 thread를 target으로 고정한다. `Daily Server Log Check`, `Notion Outbox Publish`가 이 방식을 사용한다. PR merge와 contributor upstream 동기화는 예약 자동화가 아니라 `$sk-git`의 역할별 흐름으로 처리한다. OWNER의 canonical plain `$sk-git`은 현재 저장소 PR을 발견·검토·merge하고, NON_OWNER의 `$sk-git`은 merge 후 clean/ff-only 조건에서 upstream main을 반영한다.
+
 기본 프롬프트:
 
 ```text

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

@@ -98,7 +98,7 @@ $sk-git
 ```
 
 DB 관련 코드, repository/query, SQL, migration, verification, rollback 파일까지 작성해 PR로 전달할 수 있다. 단 모든 DB target은 production이므로 Codex/local test/CI에서 실행하지 않는다.
-`$sk-deploy`는 OWNER만 가진 SSH/npm/배포 credential이 없어 실제 mutation을 진행할 수 없으므로 배포 요청은 SeoKang에게 전달한다.
+`$sk-deploy`는 사용자 유형을 판정하지 않는다. 친구 PC의 local config에 SSH/npm/배포 credential이 없으므로 실제 mutation은 원격 시스템에서 거부되며, 필요한 배포는 credential이 설정된 환경에서 실행한다.
 
 `$sk-git`은 아래를 확인해야 한다.
 
@@ -110,6 +110,8 @@ DB 관련 코드, repository/query, SQL, migration, verification, rollback 파
 
 조건을 통과하면 `$sk-git`은 commit/push 뒤 OPEN PR URL을 반환하거나, PR 이력이 없을 때 제목과 본문을 자동 생성해 `selink-lab` 원본 PR까지 만든다. CLOSED/MERGED PR branch는 재사용하지 않고 새 branch를 요구한다.
 
+PR 생성 뒤 친구가 GitHub나 `git status`를 반복 확인할 필요는 없다. SeoKang이 canonical product repository에서 plain `$sk-git`을 호출하면 현재 저장소의 허용된 contributor PR을 자동 발견해 remote diff를 검토하고, script가 CI·author·base·conflict·head/main SHA를 재검증한 뒤 순차 squash merge한다. 특정 PR 하나만 처리하려면 `$sk-git PR #<number> 병합`을 사용한다. 친구 계정은 원본 merge 권한이 없고 personal fork topology에서 merge helper도 호출하지 않는다.
+
 일반 작업 branch와 local commit은 identity/cache 없이 진행한다. push나 PR 인증이 실패하면 local commit을 보존한 채 `push pending`으로 보고하며, 인증 복구 후 이어서 처리한다.
 
 `$sk-git`은 add 전에 worktree, commit 전에 staged index, push 전에 outbound commit history를 각각 검사한다. 새 `.env*`, deploy local config, private key/keystore/credential 파일 또는 고신뢰 token이 탐지되면 확인 없이 hard-fail하며 push하지 않는다. 탐지된 값은 출력하지 않고 로컬 파일도 삭제하지 않는다. 기존 staged path도 intended commit path와 다르면 commit하지 않는다.
@@ -129,7 +131,9 @@ gh pr create \
 
 친구는 PR 작성까지만 수행한다. merge, tag, release, local/preview/staging/production 배포는 하지 않는다.
 
-## 7. 다음 작업에서 fork 동기화
+## 7. Git skill과 다음 작업의 fork 동기화
+
+SeoKang이 PR을 merge해도 친구의 개인 fork default branch를 강제로 변경하지 않는다. 친구가 merge 뒤 `$sk-git`을 다시 호출하거나 다음 `$sk-feature`/`$sk-bugfix`를 시작하면 Codex가 아래 upstream fast-forward를 수행해 원본 최신 main을 local default branch에 반영한다.
 
 ```bash
 git switch <default-branch>
@@ -141,6 +145,20 @@ git switch -c feature/<다음-작업명>
 
 충돌이 있으면 `main`에 임의 merge commit을 만들거나 force push하지 말고 SeoKang에게 전달한다.
 
+`$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. 공용 스킬 업데이트
+
+SeoKang이 새 workflow를 canonical 저장소에 반영한 뒤 친구는 아래 명령으로 새 규칙과 script를 받는다.
+
+```bash
+sk update --dry-run
+sk update
+sk check
+```
+
+친구가 수정하는 product repository와 `~/.agents/skills` canonical clone은 별개다. `sk update`가 dirty/ahead/diverged를 보고하면 skills clone을 자동 reset하지 말고 SeoKang에게 전달한다.
+
 ## 8. 허용/차단 기준
 
 | 작업 | 친구 계정 |
@@ -153,7 +171,7 @@ git switch -c feature/<다음-작업명>
 | 원본 main/feature branch 직접 push | GitHub Read 권한으로 차단 |
 | DB 코드·SQL·migration 작성과 PR | 허용, production DB 실행 금지 |
 | 실제 DB schema/data 변경 | credential 미지급 + OWNER 수동 실행으로 차단 |
-| local/preview/staging/production 배포 | OWNER credential 미지급으로 차단 |
+| local/preview/staging/production 배포 | local credential 미설정이면 실제 원격 명령에서 차단 |
 | npm/tag/release/rollback | GitHub/npm/배포 ACL과 credential로 차단 |
 
 ## 9. 계정 또는 접근 제거 시

package/docs/setup/github-free-collaboration.md

@@ -6,7 +6,7 @@
 - GitHub Team 요금제로 업그레이드하지 않고 Organization의 무료 team 기능을 사용한다.
 - 친구는 `fork-contributors` team을 통해 승인된 원본 private repository만 Read로 본다.
 - fork/PR 대상으로 승인된 repository에서만 개인 private fork에 작업 branch를 push하고 원본으로 PR을 만든다.
-- SeoKang만 merge, 모든 배포, tag/release, npm publish, rollback을 수행한다.
+- SeoKang만 merge, 모든 배포, tag/release, npm publish, rollback을 수행한다. canonical product repository의 plain `$sk-git`은 현재 저장소의 허용된 contributor PR을 자동 발견·검토·순차 merge한다.
 
 ## Organization 설정
 
@@ -55,7 +55,7 @@ GitHub Free private repository에는 branch ruleset을 강제할 수 없으므
 - 친구 push 대상은 개인 private fork뿐
 - 친구 계정의 원본 반영은 개인 fork PR과 OWNER merge만 사용하며, OWNER 자신의 작업은 canonical main에 직접 반영 가능
 - DB write 및 SSH/npm/API/CDN/production credential은 친구에게 제공하지 않음
-- 모든 배포 mutation은 OWNER만 보유한 SSH/npm/API/CDN credential과 원격 ACL로 제한
+- 모든 배포 mutation은 사용자 유형 판정 없이 local config의 SSH/npm/API/CDN credential과 원격 ACL로 실행
 - DB 코드·SQL 작성은 fork PR로 허용하되 Codex/local test/CI/deploy/startup의 DB schema/data 실행은 금지
 - 실제 DB 변경은 OWNER가 별도 IDE/DB 도구에서 수동 실행
 

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

@@ -80,7 +80,7 @@ sk setup
 - `sk setup --configure-notion`으로 사용자별 Notion workspace 위치를 로컬 파일에 분리할 수 있다.
 - `.sk/project-memory.json`, `.sk/notepad.md`를 통해 다음 세션이 이전 맥락을 먼저 읽을 수 있다.
 - `sk search`로 예전 Codex transcript를 다시 찾을 수 있다.
-- `sk guard`로 DB 자동 실행과 Git secret을 차단하고, canonical main push와 실제 배포는 GitHub ACL·OWNER credential로 제한할 수 있다.
+- `sk guard`로 DB 자동 실행과 Git secret을 차단하고, canonical main push는 GitHub ACL로 제한한다. 배포는 사용자 유형이 아니라 설정된 credential과 원격 권한으로 실행한다.
 
 ## 3. 처음 한 번만 해야 하는 것
 
@@ -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`으로 보고한다.
@@ -310,7 +313,7 @@ sk guard secrets --outbound --remote origin
 
 친구 계정의 최초 설치, remote 구성, Codex 스킬 사용, PR 생성 절차는 [친구 계정 Private Fork 개발 가이드](./fork-contributor-guide.md)를 따른다.
 
-배포는 live GitHub identity를 검사하지 않는다. 실제 차단은 OWNER만 가진 SSH/npm/production credential과 원격 ACL이 담당한다.
+배포는 live GitHub identity, local OWNER profile, 실행 사용자, process owner를 검사하거나 분류하지 않는다. 설정된 SSH/npm/production credential과 원격 시스템의 실제 명령 결과만 사용한다. `sk guard deploy`도 사용자 유형을 판정하지 않는 경계 진단이다.
 
 ```bash
 sk guard deploy \
@@ -322,7 +325,7 @@ sk guard deploy \
   --db-impact-status none
 ```
 
-- server deploy는 `scripts/check_db_execution_boundary.mjs <project-root>`를 먼저 통과해야 하며 startup migration/ORM schema sync 근거가 불명확하면 중단한다.
+- server/front/npm deploy는 helper가 `scripts/check_db_execution_boundary.mjs --mode deploy-packaging <project-root>`를 먼저 실행한다. DB 연결 test source가 존재해도 고정 packaging command에서 실행되지 않으면 허용하지만, test task 연결·npm lifecycle test·startup migration/ORM schema sync 근거가 발견되면 중단한다.
 - production, npm publish, rollback을 포함한 모든 배포 credential은 OWNER 환경에만 둔다.
 - fork PR/CI에는 production DB/SSH/npm/API/CDN secret과 write token을 전달하지 않는다.
 

package/docs/templates/task-contract.md

@@ -25,7 +25,7 @@
 ### 보안 최종 점검 필요 여부 (`해당 없음` | `필수`)
 ### DB impact (`있음` | `없음` | `미확인`)
 ### DB 실행 경계 (`해당 없음` | `production 무실행 검증` | `OWNER 수동 실행 handoff`)
-### Git/deploy gate (`해당 없음` | `OWNER main 직접 반영` | `NON_OWNER PR` | `OWNER credential`)
+### Git/deploy gate (`해당 없음` | `OWNER main 직접 반영` | `NON_OWNER PR` | `configured credential`)
 
 ## 4. 검증 계획
 

package/package.json

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

package/profiles/seokang/operator-access.json

@@ -25,8 +25,15 @@
         "test/"
       ]
     },
-    "deploy": {
-      "ownerOnly": true
+    "prMerge": {
+      "organization": "selink-lab",
+      "allowedAuthors": [
+        "91kwangmin"
+      ],
+      "strategy": "squash",
+      "requiredCheckNames": [
+        "pr-safe"
+      ]
     },
     "repositories": {
       "noAccess": [

package/scripts/check_automation_safety.mjs

@@ -76,6 +76,47 @@ const STATIC_CHECKS = [
       'memory.md',
     ],
   },
+  {
+    path: 'scripts/git_pr_merge.mjs',
+    fragments: [
+      "'--match-head-commit'",
+      "'--merge'",
+      "'--inspect-open-current'",
+      "'--preflight-current'",
+      'listOpenPullRequests',
+      '명시적인 --merge',
+      'ownerIds',
+      'ownerLogins',
+      'resolveCurrentRepository',
+      'GIT_CANONICAL_REDIRECT_UNTRUSTED',
+      "command: 'sk git preflight'",
+      'HEAD_SHA_CHANGED',
+      'MAIN_SHA_CHANGED',
+      'POST_MERGE_STATE_UNVERIFIED',
+      'POST_MERGE_MAIN_UNCHANGED',
+      'mergeStateStatus',
+      'requiresUpToDateBranch',
+      "ghJson(['api', 'user'",
+      'GITHUB_CREDENTIAL_UNAVAILABLE',
+      "protectionStatus = 'unavailable-plan'",
+    ],
+  },
+  {
+    path: 'scripts/git_pr_merge_core.mjs',
+    fragments: [
+      'CHANGED_FILES_TRUNCATED',
+      'CHANGED_FILES_COUNT_MISSING',
+      'TRUSTED_CI_SOURCE_MISMATCH',
+      'STRICT_BASE_NOT_ENFORCED',
+      'TRUSTED_CHECK_NOT_REQUIRED',
+      'ADMIN_BYPASS_NOT_BLOCKED',
+      'MERGE_STATE_NOT_CLEAN',
+      'PR_NOT_OPEN',
+      'HEAD_REPOSITORY_NOT_ALLOWED',
+      'MAIN_SHA_MISSING',
+      'BRANCH_PROTECTION_UNAVAILABLE_PLAN',
+    ],
+  },
 ];
 
 function printUsage() {
@@ -110,6 +151,10 @@ async function main() {
   const findings = [
     ...run(process.execPath, ['--check', path.join(REPO_ROOT, 'scripts', 'daily_thread_retrospective.mjs')], 'daily_thread_retrospective syntax'),
     ...run(process.execPath, ['--check', path.join(REPO_ROOT, 'scripts', 'notion_outbox.mjs')], 'notion_outbox syntax'),
+    ...run(process.execPath, ['--check', path.join(REPO_ROOT, 'scripts', 'git_pr_merge_core.mjs')], 'git_pr_merge_core syntax'),
+    ...run(process.execPath, ['--check', path.join(REPO_ROOT, 'scripts', 'git_pr_merge.mjs')], 'git_pr_merge syntax'),
+    ...run(process.execPath, [path.join(REPO_ROOT, 'scripts', 'check_git_pr_merge.mjs')], 'git_pr_merge harness'),
+    ...run(process.execPath, [path.join(REPO_ROOT, 'scripts', 'check_git_pr_merge_integration.mjs')], 'git_pr_merge fake-gh integration'),
     ...run('bash', ['-n', path.join(REPO_ROOT, 'scripts', 'daily_server_log_check.sh')], 'daily_server_log_check syntax'),
   ];
 

package/scripts/check_db_execution_boundary.mjs

@@ -41,11 +41,17 @@ const RULES = [
 function parseArgs(argv) {
   const targets = [];
   let json = false;
-  for (const arg of argv) {
+  let mode = 'strict';
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
     if (arg === '--json') json = true;
+    else if (arg === '--mode') mode = argv[++index];
     else targets.push(path.resolve(arg));
   }
-  return { targets: targets.length > 0 ? targets : [process.cwd()], json };
+  if (!['strict', 'deploy-packaging'].includes(mode)) {
+    throw new Error(`지원하지 않는 DB execution boundary mode: ${mode || '(empty)'}`);
+  }
+  return { targets: targets.length > 0 ? targets : [process.cwd()], json, mode };
 }
 
 function shouldScan(filePath) {
@@ -119,7 +125,100 @@ function workflowHasUnguardedExecution(content) {
   return false;
 }
 
-const { targets, json } = parseArgs(process.argv.slice(2));
+function commandRunsTests(command, baseDirectory, contents, visitedShellFiles = new Set()) {
+  if (/\b(?:npm|pnpm|yarn|bun)\s+(?:(?:run|run-script)\s+)?(?:test|test:[\w-]+|integration(?:-?test)?|e2e)\b|\b(?:jest|vitest|mocha)\b/i.test(command)) {
+    return true;
+  }
+
+  const shellReferences = [];
+  for (const match of command.matchAll(/(?:^|[\s;&|])(?:bash|sh|zsh)\s+(["']?)([^\s"';&|]+\.sh)\1/gi)) shellReferences.push(match[2]);
+  for (const match of command.matchAll(/(?:^|[\s;&|])((?:\.\/|\.\.\/)[^\s;&|]+\.sh)\b/gi)) shellReferences.push(match[1]);
+  for (const reference of shellReferences) {
+    const shellPath = path.resolve(baseDirectory, reference);
+    if (visitedShellFiles.has(shellPath)) continue;
+    const shellContent = contents.get(shellPath);
+    if (typeof shellContent !== 'string') continue;
+    visitedShellFiles.add(shellPath);
+    if (commandRunsTests(shellContent, path.dirname(shellPath), contents, visitedShellFiles)) return true;
+  }
+  return false;
+}
+
+function packageDeployLifecycleRunsTests(content, filePath, contents) {
+  let packageDocument;
+  try {
+    packageDocument = JSON.parse(content);
+  } catch {
+    return false;
+  }
+  const scripts = packageDocument?.scripts;
+  if (!scripts || typeof scripts !== 'object') return false;
+  const entrypoints = [
+    'prebuild-prod', 'build-prod', 'postbuild-prod',
+    'prepack', 'prepare', 'prepublish', 'prepublishOnly', 'publish', 'postpublish', 'postpack',
+  ];
+  const visited = new Set();
+  const queue = entrypoints.filter((name) => typeof scripts[name] === 'string');
+  while (queue.length > 0) {
+    const name = queue.shift();
+    if (visited.has(name)) continue;
+    visited.add(name);
+    const command = scripts[name];
+    if (commandRunsTests(command, path.dirname(filePath), contents)) {
+      return true;
+    }
+    for (const match of command.matchAll(/\b(?:npm|pnpm|yarn|bun)\s+(?:run|run-script)\s+([\w:-]+)/gi)) {
+      if (typeof scripts[match[1]] === 'string') queue.push(match[1]);
+    }
+  }
+  return false;
+}
+
+function gradleDependencyTargets(expression) {
+  const ignored = new Set(['dependsOn', 'finalizedBy', 'tasks', 'task', 'named', 'register', 'getByName', 'get']);
+  const targets = new Set();
+  for (const match of expression.matchAll(/['"]([A-Za-z][\w-]*)['"]/g)) targets.add(match[1]);
+  for (const match of expression.matchAll(/\b([A-Za-z][\w-]*)\b/g)) {
+    if (!ignored.has(match[1])) targets.add(match[1]);
+  }
+  return [...targets];
+}
+
+function gradleDeployPackagingRunsTests(content) {
+  const graph = new Map();
+  const addEdges = (source, expression) => {
+    if (!graph.has(source)) graph.set(source, new Set());
+    for (const target of gradleDependencyTargets(expression)) {
+      if (target !== source) graph.get(source).add(target);
+    }
+  };
+
+  for (const match of content.matchAll(/\b([A-Za-z][\w-]*)\s*\.\s*(?:dependsOn|finalizedBy)\s*\(?([^\n)]*)/g)) {
+    addEdges(match[1], match[2]);
+  }
+  const blockPatterns = [
+    /tasks\.(?:named|register)\s*\(\s*['"]([A-Za-z][\w-]*)['"][^)]*\)\s*\{([\s\S]{0,2000}?)\n?\}/g,
+    /(?:^|\n)\s*([A-Za-z][\w-]*)\s*\{([\s\S]{0,2000}?)\n?\}/g,
+  ];
+  for (const pattern of blockPatterns) {
+    for (const block of content.matchAll(pattern)) {
+      for (const edge of block[2].matchAll(/(?:dependsOn|finalizedBy)\s*\(?([^\n)]*)/g)) addEdges(block[1], edge[1]);
+    }
+  }
+
+  const queue = ['assemble', 'bootJar'];
+  const visited = new Set();
+  while (queue.length > 0) {
+    const task = queue.shift();
+    if (visited.has(task)) continue;
+    visited.add(task);
+    if (/^(?:test|check|integration[-_]?test)$/i.test(task) || /(?:Test|Tests|Check)$/.test(task)) return true;
+    for (const dependency of graph.get(task) || []) queue.push(dependency);
+  }
+  return false;
+}
+
+const { targets, json, mode } = parseArgs(process.argv.slice(2));
 const files = [];
 for (const target of targets) await collect(target, files);
 
@@ -188,18 +287,36 @@ for (const proof of [
   }
 }
 
-const uniqueViolations = [...new Map(violations.map((entry) => [`${entry.file}:${entry.rule}`, entry])).values()];
+if (mode === 'deploy-packaging') {
+  for (const [filePath, content] of contents) {
+    const name = path.basename(filePath);
+    if (name === 'package.json' && packageDeployLifecycleRunsTests(content, filePath, contents)) {
+      violations.push({ file: relativeDisplay(filePath), rule: 'DEPLOY_DATABASE_TEST_EXECUTION' });
+    }
+    if (/^build\.gradle(?:\.kts)?$/i.test(name) && gradleDeployPackagingRunsTests(content)) {
+      violations.push({ file: relativeDisplay(filePath), rule: 'DEPLOY_DATABASE_TEST_EXECUTION' });
+    }
+  }
+}
+
+const uniqueFindings = [...new Map(violations.map((entry) => [`${entry.file}:${entry.rule}`, entry])).values()];
+const advisoryRules = mode === 'deploy-packaging' ? new Set(['TEST_DATABASE_CONNECTION']) : new Set();
+const advisories = uniqueFindings.filter((entry) => advisoryRules.has(entry.rule));
+const uniqueViolations = uniqueFindings.filter((entry) => !advisoryRules.has(entry.rule));
 const payload = {
   decision: uniqueViolations.length === 0 ? 'ALLOW' : 'DENY',
+  mode,
   scanned_files: files.length,
   db_execution_allowed: false,
+  advisories,
   violations: uniqueViolations,
 };
 
 if (json) {
   console.log(JSON.stringify(payload, null, 2));
 } else if (payload.decision === 'ALLOW') {
-  console.log(`DB execution boundary: PASS (${files.length} files, mutation execution 없음)`);
+  const advisoryText = advisories.length > 0 ? `, 실행되지 않는 DB test source ${advisories.length}건` : '';
+  console.log(`DB execution boundary: PASS (${files.length} files, mutation execution 없음${advisoryText})`);
 } else {
   console.error('DB execution boundary: DENY');
   for (const violation of uniqueViolations) console.error(`- ${violation.file} [${violation.rule}]`);

package/scripts/check_db_execution_boundary_smoke.mjs

@@ -14,8 +14,8 @@ function fail(message) {
   process.exit(1);
 }
 
-function run(target) {
-  return spawnSync(process.execPath, [CHECKER, target, '--json'], { encoding: 'utf8' });
+function run(target, mode = 'strict') {
+  return spawnSync(process.execPath, [CHECKER, '--mode', mode, target, '--json'], { encoding: 'utf8' });
 }
 
 const tempRoot = await mkdtemp(path.join(tmpdir(), 'sk-db-execution-boundary-'));
@@ -94,6 +94,76 @@ jobs:
   if (connectedTest.status !== 2 || !connectedTest.stdout.includes('TEST_DATABASE_CONNECTION')) {
     fail(`DB 연결 가능 test fixture가 차단되지 않았습니다: ${connectedTest.stdout}${connectedTest.stderr}`);
   }
+  const connectedTestPackaging = run(connectedTestRoot, 'deploy-packaging');
+  if (connectedTestPackaging.status !== 0 || !connectedTestPackaging.stdout.includes('TEST_DATABASE_CONNECTION')) {
+    fail(`실행되지 않는 DB 연결 test source가 deploy packaging을 차단했습니다: ${connectedTestPackaging.stdout}${connectedTestPackaging.stderr}`);
+  }
+
+  await writeFile(
+    path.join(connectedTestRoot, 'build.gradle'),
+    'plugins { id "java" }\nassemble.dependsOn test\n',
+  );
+  const connectedTestExecution = run(connectedTestRoot, 'deploy-packaging');
+  if (connectedTestExecution.status !== 2 || !connectedTestExecution.stdout.includes('DEPLOY_DATABASE_TEST_EXECUTION')) {
+    fail(`deploy packaging에 연결된 DB test 실행 경로가 차단되지 않았습니다: ${connectedTestExecution.stdout}${connectedTestExecution.stderr}`);
+  }
+
+  const npmLifecycleRoot = path.join(tempRoot, 'npm-lifecycle-test');
+  await mkdir(path.join(npmLifecycleRoot, 'tests'), { recursive: true });
+  await writeFile(path.join(npmLifecycleRoot, 'tests', 'db.test.js'), 'const url = process.env.DATABASE_URL;\n');
+  await writeFile(path.join(npmLifecycleRoot, 'package.json'), JSON.stringify({ scripts: { prepack: 'npm test', test: 'vitest' } }));
+  const npmLifecycle = run(npmLifecycleRoot, 'deploy-packaging');
+  if (npmLifecycle.status !== 2 || !npmLifecycle.stdout.includes('DEPLOY_DATABASE_TEST_EXECUTION')) {
+    fail(`npm deploy lifecycle의 DB test 실행 경로가 차단되지 않았습니다: ${npmLifecycle.stdout}${npmLifecycle.stderr}`);
+  }
+
+  const unknownTestLifecycleRoot = path.join(tempRoot, 'npm-unknown-test-lifecycle');
+  await mkdir(unknownTestLifecycleRoot, { recursive: true });
+  await writeFile(
+    path.join(unknownTestLifecycleRoot, 'package.json'),
+    JSON.stringify({ scripts: { prepack: 'npm test', test: 'node ./custom-check.mjs' } }),
+  );
+  await writeFile(path.join(unknownTestLifecycleRoot, 'custom-check.mjs'), 'console.log("custom check");\n');
+  const unknownTestLifecycle = run(unknownTestLifecycleRoot, 'deploy-packaging');
+  if (unknownTestLifecycle.status !== 2 || !unknownTestLifecycle.stdout.includes('DEPLOY_DATABASE_TEST_EXECUTION')) {
+    fail(`DB test source 탐지 여부와 무관한 npm packaging 검증 실행 경로가 차단되지 않았습니다: ${unknownTestLifecycle.stdout}${unknownTestLifecycle.stderr}`);
+  }
+
+  const shellLifecycleRoot = path.join(tempRoot, 'npm-shell-lifecycle');
+  await mkdir(path.join(shellLifecycleRoot, 'scripts'), { recursive: true });
+  await writeFile(path.join(shellLifecycleRoot, 'package.json'), JSON.stringify({ scripts: { prepack: 'bash scripts/verify.sh' } }));
+  await writeFile(path.join(shellLifecycleRoot, 'scripts', 'verify.sh'), '#!/bin/sh\nnpm test\n');
+  const shellLifecycle = run(shellLifecycleRoot, 'deploy-packaging');
+  if (shellLifecycle.status !== 2 || !shellLifecycle.stdout.includes('DEPLOY_DATABASE_TEST_EXECUTION')) {
+    fail(`이름이 중립적인 shell script를 통한 npm test 실행 경로가 차단되지 않았습니다: ${shellLifecycle.stdout}${shellLifecycle.stderr}`);
+  }
+
+  const gradleFinalizerRoot = path.join(tempRoot, 'gradle-finalizer-test');
+  await mkdir(gradleFinalizerRoot, { recursive: true });
+  await writeFile(path.join(gradleFinalizerRoot, 'build.gradle'), 'plugins { id "java" }\nassemble.finalizedBy integrationTest\n');
+  const gradleFinalizer = run(gradleFinalizerRoot, 'deploy-packaging');
+  if (gradleFinalizer.status !== 2 || !gradleFinalizer.stdout.includes('DEPLOY_DATABASE_TEST_EXECUTION')) {
+    fail(`Gradle packaging finalizer의 test 실행 경로가 차단되지 않았습니다: ${gradleFinalizer.stdout}${gradleFinalizer.stderr}`);
+  }
+
+  const gradleClosureRoot = path.join(tempRoot, 'gradle-closure-test');
+  await mkdir(gradleClosureRoot, { recursive: true });
+  await writeFile(path.join(gradleClosureRoot, 'build.gradle'), 'plugins { id "java" }\nassemble {\n  dependsOn test\n}\n');
+  const gradleClosure = run(gradleClosureRoot, 'deploy-packaging');
+  if (gradleClosure.status !== 2 || !gradleClosure.stdout.includes('DEPLOY_DATABASE_TEST_EXECUTION')) {
+    fail(`Gradle closure packaging의 test 실행 경로가 차단되지 않았습니다: ${gradleClosure.stdout}${gradleClosure.stderr}`);
+  }
+
+  const gradleIndirectRoot = path.join(tempRoot, 'gradle-indirect-test');
+  await mkdir(gradleIndirectRoot, { recursive: true });
+  await writeFile(
+    path.join(gradleIndirectRoot, 'build.gradle'),
+    'plugins { id "java" }\nassemble.dependsOn verifyProd\nverifyProd.dependsOn test\n',
+  );
+  const gradleIndirect = run(gradleIndirectRoot, 'deploy-packaging');
+  if (gradleIndirect.status !== 2 || !gradleIndirect.stdout.includes('DEPLOY_DATABASE_TEST_EXECUTION')) {
+    fail(`Gradle packaging의 간접 test dependency가 차단되지 않았습니다: ${gradleIndirect.stdout}${gradleIndirect.stderr}`);
+  }
 
   const testcontainersRoot = path.join(tempRoot, 'testcontainers');
   await mkdir(testcontainersRoot, { recursive: true });