@dusky-bluehour/agent-service 0.6.6 → 0.6.8

package/scripts/validate.mjs

@@ -12,7 +12,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const rootDir = path.resolve(__dirname, '..');
 
-const toolDirs = ['claude-code', 'codex', 'antigravity'];
+const toolDirs = ['claude-code', 'codex', 'gemini'];
 const errors = [];
 
 function fail(message) {
@@ -51,6 +51,18 @@ function parseFrontmatter(content) {
   return result;
 }
 
+function normalizeCommandBasename(commandId) {
+  const normalized = String(commandId ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  if (!normalized) {
+    throw new Error(`invalid command id: ${commandId}`);
+  }
+  return normalized;
+}
+
 async function validateCatalog() {
   const catalogPath = path.join(rootDir, 'catalog', 'tool-catalog.ko.json');
   if (!(await exists(catalogPath))) {
@@ -193,10 +205,11 @@ async function validateCommonSources() {
     'common/commands/command-catalog.json',
     'common/workflows/workflow-catalog.json',
     'common/skills/skill-catalog.json',
+    'common/settings/security-policy.json',
     'common/claude/subagent-catalog.json',
     'common/claude/team-catalog.json',
-    'common/antigravity/agent-catalog.json',
-    'common/antigravity/artifact-catalog.json'
+    'common/gemini/agent-catalog.json',
+    'common/gemini/artifact-catalog.json'
   ];
 
   const commonData = {};
@@ -220,10 +233,8 @@ async function validateCommonSources() {
     }
 
     const toolSet = new Set(Array.isArray(workflowCatalog.tools) ? workflowCatalog.tools : []);
-    for (const toolId of toolDirs) {
-      if (!toolSet.has(toolId)) {
-        fail(`[common/workflows] tools에 필수 tool 누락: ${toolId}`);
-      }
+    if (!toolSet.has('gemini')) {
+      fail('[common/workflows] tools에 필수 tool 누락: gemini');
     }
 
     if (!workflowCatalog.workflow_policy || typeof workflowCatalog.workflow_policy !== 'object') {
@@ -358,6 +369,21 @@ async function validateCommonSources() {
           fail(`[common/skills] 중단 조건 누락: ${skill.id}`);
         }
 
+        for (const toolId of toolSet) {
+          const procedures = skill.procedures?.[toolId] ?? [];
+          for (const step of procedures) {
+            if (/\bCMD-[A-Z]/.test(step)) {
+              fail(`[common/skills] CMD-* 참조 금지 위반: ${skill.id}/${toolId} → "${step.slice(0, 60)}…"`);
+            }
+            if (/\bWF-[A-Z]/.test(step)) {
+              fail(`[common/skills] WF-* 참조 금지 위반: ${skill.id}/${toolId} → "${step.slice(0, 60)}…"`);
+            }
+            if (/\bART-[A-Z]/.test(step)) {
+              fail(`[common/skills] ART-* 참조 금지 위반: ${skill.id}/${toolId} → "${step.slice(0, 60)}…"`);
+            }
+          }
+        }
+
         if (!skill.codex_openai) {
           fail(`[common/skills] codex_openai 누락: ${skill.id}`);
         } else {
@@ -369,6 +395,30 @@ async function validateCommonSources() {
       }
     }
   }
+
+  const securityPolicy = commonData['common/settings/security-policy.json'];
+  if (securityPolicy) {
+    if (!securityPolicy.policy_id || !securityPolicy.shared_permissions) {
+      fail('[common/settings] policy_id/shared_permissions 누락');
+    }
+    const shared = securityPolicy.shared_permissions ?? {};
+    for (const field of [
+      'allow_bash',
+      'ask_bash',
+      'deny_bash',
+      'deny_read',
+      'deny_edit'
+    ]) {
+      if (!Array.isArray(shared[field])) {
+        fail(`[common/settings] 배열 누락: ${field}`);
+      }
+    }
+
+    const claude = securityPolicy.claude_code ?? {};
+    if (!claude.default_mode || !claude.disable_bypass_permissions_mode) {
+      fail('[common/settings] claude_code default_mode/disable_bypass_permissions_mode 누락');
+    }
+  }
 }
 
 async function validatePackageJson() {
@@ -407,7 +457,7 @@ async function validatePackageJson() {
   const requiredFiles = [
     'common',
     'claude-code',
-    'antigravity',
+    'gemini',
     'codex',
     'catalog/tool-catalog.ko.json',
     'scripts/init.mjs',
@@ -506,7 +556,7 @@ async function validateCommandCatalog(toolName) {
   const filePath = path.join(rootDir, toolName, 'commands', 'command-catalog.json');
   if (!(await exists(filePath))) {
     fail(`[${toolName}] command-catalog.json 누락`);
-    return { commandIds: new Set() };
+    return { commandIds: new Set(), commandFileBases: new Set() };
   }
 
   let data;
@@ -514,12 +564,12 @@ async function validateCommandCatalog(toolName) {
     data = await readJson(filePath);
   } catch (error) {
     fail(`[${toolName}] command-catalog.json 파싱 실패: ${error.message}`);
-    return { commandIds: new Set() };
+    return { commandIds: new Set(), commandFileBases: new Set() };
   }
 
   if (!Array.isArray(data.commands) || data.commands.length === 0) {
     fail(`[${toolName}] commands 배열 누락 또는 비어 있음`);
-    return { commandIds: new Set() };
+    return { commandIds: new Set(), commandFileBases: new Set() };
   }
 
   const requiredFields = [
@@ -536,6 +586,7 @@ async function validateCommandCatalog(toolName) {
   ];
 
   const commandIds = new Set();
+  const commandFileBases = new Set();
   for (const cmd of data.commands) {
     for (const field of requiredFields) {
       if (!(field in cmd)) {
@@ -552,6 +603,11 @@ async function validateCommandCatalog(toolName) {
       fail(`[${toolName}] 중복 명령 ID: ${cmd.id}`);
     }
     commandIds.add(cmd.id);
+    try {
+      commandFileBases.add(normalizeCommandBasename(cmd.id));
+    } catch (error) {
+      fail(`[${toolName}] 명령 ID 형식 오류: ${cmd.id} (${error.message})`);
+    }
   }
 
   const repeatedIds = [
@@ -566,7 +622,7 @@ async function validateCommandCatalog(toolName) {
     }
   }
 
-  return { commandIds };
+  return { commandIds, commandFileBases };
 }
 
 async function validateWorkflowCatalog(toolName, commandIds) {
@@ -620,7 +676,7 @@ async function validateWorkflowCatalog(toolName, commandIds) {
   }
 }
 
-async function validateClaudeExtras() {
+async function validateClaudeExtras(commandFileBases) {
   const subagentsPath = path.join(rootDir, 'claude-code', 'subagents');
   if (!(await exists(subagentsPath))) {
     fail('[claude-code] subagents 디렉터리 누락');
@@ -645,30 +701,58 @@ async function validateClaudeExtras() {
   if (!(await exists(teamCatalog))) {
     fail('[claude-code] team-catalog.json 누락');
   }
+
+  const commandDir = path.join(rootDir, 'claude-code', 'commands', 'native');
+  if (!(await exists(commandDir))) {
+    fail('[claude-code] commands/native 디렉터리 누락');
+    return;
+  }
+
+  const commandFiles = new Set((await fs.readdir(commandDir)).filter((file) => file.endsWith('.md')));
+  for (const base of commandFileBases) {
+    const expected = `${base}.md`;
+    if (!commandFiles.has(expected)) {
+      fail(`[claude-code] native command 누락: commands/native/${expected}`);
+    }
+  }
+}
+
+async function validateCodexExtras(commandFileBases) {
+  const codexSkillDir = path.join(rootDir, 'codex', 'skills');
+  for (const base of commandFileBases) {
+    const skillFile = path.join(codexSkillDir, base, 'SKILL.md');
+    const openAiYaml = path.join(codexSkillDir, base, 'agents', 'openai.yaml');
+    if (!(await exists(skillFile))) {
+      fail(`[codex] 명령 스킬 누락: skills/${base}/SKILL.md`);
+    }
+    if (!(await exists(openAiYaml))) {
+      fail(`[codex] 명령 스킬 openai.yaml 누락: skills/${base}/agents/openai.yaml`);
+    }
+  }
 }
 
-async function validateAntigravityExtras() {
-  const agentCatalog = path.join(rootDir, 'antigravity', 'agents', 'agent-catalog.json');
-  const artifactCatalog = path.join(rootDir, 'antigravity', 'artifacts', 'artifact-catalog.json');
+async function validateGeminiExtras(commandFileBases) {
+  const agentCatalog = path.join(rootDir, 'gemini', 'agents', 'agent-catalog.json');
+  const artifactCatalog = path.join(rootDir, 'gemini', 'artifacts', 'artifact-catalog.json');
 
   for (const f of [agentCatalog, artifactCatalog]) {
     if (!(await exists(f))) {
-      fail(`[antigravity] 누락: ${path.relative(rootDir, f)}`);
+      fail(`[gemini] 누락: ${path.relative(rootDir, f)}`);
       continue;
     }
 
     try {
       await readJson(f);
     } catch (error) {
-      fail(`[antigravity] JSON 파싱 실패: ${path.relative(rootDir, f)} (${error.message})`);
+      fail(`[gemini] JSON 파싱 실패: ${path.relative(rootDir, f)} (${error.message})`);
     }
   }
 
-  const workflowCatalogPath = path.join(rootDir, 'antigravity', 'workflows', 'workflow-catalog.json');
-  const workflowDefsDir = path.join(rootDir, 'antigravity', 'workflows', 'definitions');
+  const workflowCatalogPath = path.join(rootDir, 'gemini', 'workflows', 'workflow-catalog.json');
+  const workflowDefsDir = path.join(rootDir, 'gemini', 'workflows', 'definitions');
 
   if (!(await exists(workflowDefsDir))) {
-    fail('[antigravity] workflow definitions 디렉터리 누락');
+    fail('[gemini] workflow definitions 디렉터리 누락');
     return;
   }
 
@@ -676,7 +760,7 @@ async function validateAntigravityExtras() {
   try {
     workflowCatalog = await readJson(workflowCatalogPath);
   } catch (error) {
-    fail(`[antigravity] workflow-catalog.json 파싱 실패: ${error.message}`);
+    fail(`[gemini] workflow-catalog.json 파싱 실패: ${error.message}`);
     return;
   }
 
@@ -690,7 +774,39 @@ async function validateAntigravityExtras() {
   for (const workflowId of workflowIds) {
     const expected = `${workflowId}.workflow.yaml`;
     if (!definitionFiles.includes(expected)) {
-      fail(`[antigravity] workflow definition 누락: ${expected}`);
+      fail(`[gemini] workflow definition 누락: ${expected}`);
+    }
+  }
+
+  const commandDefinitionsDir = path.join(rootDir, 'gemini', 'commands', 'definitions');
+  if (!(await exists(commandDefinitionsDir))) {
+    fail('[gemini] commands/definitions 디렉터리 누락');
+    return;
+  }
+
+  const commandDefinitionFiles = new Set(
+    (await fs.readdir(commandDefinitionsDir)).filter((file) => file.endsWith('.toml'))
+  );
+  for (const base of commandFileBases) {
+    const expected = `${base}.toml`;
+    if (!commandDefinitionFiles.has(expected)) {
+      fail(`[gemini] command definition 누락: commands/definitions/${expected}`);
+    }
+  }
+
+  const extensionJsonPath = path.join(rootDir, 'gemini', 'gemini-extension.json');
+  if (!(await exists(extensionJsonPath))) {
+    fail('[gemini] gemini-extension.json 누락');
+  } else {
+    try {
+      const extensionData = await readJson(extensionJsonPath);
+      for (const field of ['name', 'version', 'description']) {
+        if (!extensionData[field]) {
+          fail(`[gemini] gemini-extension.json 필수 필드 누락: ${field}`);
+        }
+      }
+    } catch (error) {
+      fail(`[gemini] gemini-extension.json 파싱 실패: ${error.message}`);
     }
   }
 }
@@ -704,6 +820,89 @@ async function validateReadmes() {
   }
 }
 
+async function validateSettingsOutputs() {
+  const settingsFiles = [
+    'claude-code/settings/settings.json',
+    'claude-code/settings/settings.local.json',
+    'gemini/settings/editor-policy.json',
+    'codex/settings/runtime-policy.json'
+  ];
+
+  for (const relPath of settingsFiles) {
+    const fullPath = path.join(rootDir, relPath);
+    if (!(await exists(fullPath))) {
+      fail(`[settings] 파일 누락: ${relPath}`);
+      continue;
+    }
+    try {
+      await readJson(fullPath);
+    } catch (error) {
+      fail(`[settings] JSON 파싱 실패: ${relPath} (${error.message})`);
+    }
+  }
+
+  const claudeProjectPath = path.join(
+    rootDir,
+    'claude-code',
+    'settings',
+    'settings.json'
+  );
+  if (await exists(claudeProjectPath)) {
+    try {
+      const claude = await readJson(claudeProjectPath);
+      const permissions = claude.permissions ?? {};
+      const validModes = new Set([
+        'default',
+        'acceptEdits',
+        'plan',
+        'dontAsk',
+        'bypassPermissions'
+      ]);
+      if (!validModes.has(permissions.defaultMode)) {
+        fail(`[settings] Claude defaultMode 값 오류: ${permissions.defaultMode}`);
+      }
+      for (const key of ['allow', 'ask', 'deny']) {
+        if (!Array.isArray(permissions[key])) {
+          fail(`[settings] Claude permissions.${key} 누락`);
+        }
+      }
+    } catch (error) {
+      fail(`[settings] Claude 설정 검증 실패: ${error.message}`);
+    }
+  }
+
+  const codexAgentsPermissionPath = path.join(
+    rootDir,
+    'codex',
+    'instructions',
+    'AGENTS.permissions.generated.md'
+  );
+  if (!(await exists(codexAgentsPermissionPath))) {
+    fail('[settings] Codex AGENTS.permissions.generated.md 누락');
+  }
+}
+
+async function validateProjectRuleTemplates() {
+  const requiredFiles = [
+    'claude-code/instructions/CLAUDE.template.md',
+    'codex/instructions/AGENTS.template.md',
+    'gemini/instructions/GEMINI.template.md'
+  ];
+
+  for (const relPath of requiredFiles) {
+    const fullPath = path.join(rootDir, relPath);
+    if (!(await exists(fullPath))) {
+      fail(`[project-rules] 템플릿 누락: ${relPath}`);
+      continue;
+    }
+
+    const content = await fs.readFile(fullPath, 'utf8');
+    if (!content.trim()) {
+      fail(`[project-rules] 템플릿 비어 있음: ${relPath}`);
+    }
+  }
+}
+
 async function runCliSmokeTests() {
   const nodeBin = process.execPath;
   const cliPath = path.join(rootDir, 'scripts', 'init.mjs');
@@ -723,7 +922,7 @@ async function runCliSmokeTests() {
         '--tool',
         'codex',
         '--components',
-        'skills,workflows,commands',
+        'skills,commands',
         '--target',
         '/tmp/tri-agent-manager-validate',
         '--dry-run',
@@ -765,7 +964,7 @@ async function runCliSmokeTests() {
         '--tool',
         'codex',
         '--components',
-        'skills,workflows,commands',
+        'skills,commands',
         '--target',
         '/tmp/tri-agent-manager-validate',
         '--dry-run',
@@ -785,11 +984,11 @@ async function runCliSmokeTests() {
         cliPath,
         'install',
         '--tool',
-        'antigravity',
+        'gemini',
         '--components',
         'skills,workflows',
         '--install-root',
-        'antigravity=.agent-custom',
+        'gemini=.gemini-custom',
         '--target',
         '/tmp/tri-agent-manager-validate',
         '--dry-run',
@@ -802,6 +1001,30 @@ async function runCliSmokeTests() {
     fail(`[cli] install --install-root dry-run 실행 실패: ${error.message}`);
   }
 
+  try {
+    await execFileAsync(
+      nodeBin,
+      [
+        cliPath,
+        'install',
+        '--tool',
+        'gemini',
+        '--components',
+        'skills',
+        '--project-rules',
+        'if-instructions',
+        '--target',
+        '/tmp/tri-agent-manager-validate',
+        '--dry-run',
+        '--yes',
+        '--non-interactive'
+      ],
+      { cwd: rootDir }
+    );
+  } catch (error) {
+    fail(`[cli] install --project-rules dry-run 실행 실패: ${error.message}`);
+  }
+
   try {
     await execFileAsync(
       nodeBin,
@@ -851,7 +1074,7 @@ async function runCliSmokeTests() {
         '--tool',
         'codex',
         '--components',
-        'skills,workflows,commands',
+        'skills,commands',
         '--target',
         '/tmp/tri-agent-manager-validate',
         '--dry-run',
@@ -870,15 +1093,24 @@ async function main() {
   await validateCommonSources();
   await validateCatalog();
   await validateReadmes();
+  await validateSettingsOutputs();
+  await validateProjectRuleTemplates();
 
+  const commandFileBaseByTool = {};
+  let geminiCommandIds = new Set();
   for (const toolName of toolDirs) {
     await validateSkillDirectory(toolName);
-    const { commandIds } = await validateCommandCatalog(toolName);
-    await validateWorkflowCatalog(toolName, commandIds);
+    const { commandIds, commandFileBases } = await validateCommandCatalog(toolName);
+    commandFileBaseByTool[toolName] = commandFileBases;
+    if (toolName === 'gemini') {
+      geminiCommandIds = commandIds;
+    }
   }
+  await validateWorkflowCatalog('gemini', geminiCommandIds);
 
-  await validateClaudeExtras();
-  await validateAntigravityExtras();
+  await validateClaudeExtras(commandFileBaseByTool['claude-code'] ?? new Set());
+  await validateCodexExtras(commandFileBaseByTool.codex ?? new Set());
+  await validateGeminiExtras(commandFileBaseByTool.gemini ?? new Set());
   await runCliSmokeTests();
 
   if (errors.length > 0) {

package/antigravity/README.md

@@ -1,43 +0,0 @@
-# Antigravity 운영팩
-
-이 폴더는 Antigravity의 Manager-에이전트-Artifact 흐름을 기준으로, 서비스 운영 전체를 실행 가능한 형태로 정리한 패키지입니다.
-정의 원천은 저장소 `common/*`이며, 이 폴더의 파일은 생성 스크립트(`npm run generate`) 결과입니다.
-직접 수정 대신 공통 원천을 수정한 뒤 재생성해 주세요.
-
-## 폴더 구성
-
-- `skills/`: 역할별 실행 스킬
-- `agents/agent-catalog.json`: 에이전트 역할 카탈로그
-- `artifacts/artifact-catalog.json`: 단계별 Artifact 계약
-- `workflows/workflow-catalog.json`: 오케스트레이션 워크플로우
-- `workflows/definitions/*.workflow.yaml`: Antigravity 실행용 워크플로우 정의 파일
-- `commands/command-catalog.json`: 공통 명령 계약
-
-## 빠른 시작
-
-1. `WF-SERVICE-E2E`(기본 E2E), `WF-SECURITY-HARDENING`(보안), `WF-INCIDENT-RESPONSE`(장애 대응), `WF-PRD-TO-PRODUCTION`(PRD→구현) 등 목적별 워크플로우를 선택해 주세요.
-2. 각 단계의 `input_artifact` 필드를 먼저 검증해 주세요.
-3. 지정된 `agent`가 `commands`를 수행합니다.
-4. `output_artifact` 검증 후 다음 단계로 진행해 주세요.
-
-워크플로우 카탈로그에서 선택한 ID와 동일한 이름의 정의 파일을 `workflows/definitions/`에서 사용하시면 됩니다. 예: `WF-SERVICE-E2E.workflow.yaml`
-
-## 반복 작업 역할 분리
-
-- UI 컴포넌트화: `frontend-repetition-agent` + `CMD-DEV-FE-UI-COMPONENTIZE`
-- Hook 분리: `frontend-repetition-agent` + `CMD-DEV-FE-HOOK-SEPARATE`
-- 성능 최적화: `performance-agent` + `CMD-DEV-PERF-OPTIMIZE`
-- 변경점 안전 검토: `change-safety-review` + `CMD-TEST-UNIT-INTEGRATION`, `CMD-REVIEW-CODE`
-- PRD 작성: `prd-writer-agent`
-
-## 운영 규칙
-
-- Manager 에이전트가 단계 전환 권한을 가집니다.
-- Artifact 검증 실패 시 단계 중단 후 원인 수정을 우선해 주세요.
-- 보안/배포 단계는 우회 없이 게이트를 통과해야 합니다.
-
-## 참고 문서 (검증일: 2026-02-17)
-
-- [Google Antigravity 발표](https://developers.googleblog.com/build-with-google-antigravity-our-new-agentic-development-platform/)
-- [Antigravity 공식 문서](https://antigravity.dev/docs)
-- [Antigravity 워크플로우 문서](https://antigravity.im/documentation)

package/antigravity/skills/frontend-repetition-pack/SKILL.md

@@ -1,35 +0,0 @@
----
-name: frontend-repetition-pack
-description: UI 컴포넌트화, Hook 분리, 성능 최적화를 표준 단계로 실행한다. 반복 프론트엔드 개선 작업에서 사용한다.
----
-
-# 시작 전 체크리스트
-
-- 중복 UI 후보 목록을 수집한다 (화면/컴포넌트/사용 횟수).
-- 기준 지표를 기록한다 (번들 크기, 렌더 횟수, 핵심 UX 지연 시간).
-- 디자인 토큰/컴포넌트 규칙을 확인한다.
-- 상태 로직 분리 대상(부수효과/비동기/공유 상태)을 표시한다.
-
-# 실행 절차
-
-1. `CMD-DEV-FE-UI-COMPONENTIZE`
-2. `CMD-DEV-FE-HOOK-SEPARATE`
-3. `CMD-DEV-PERF-OPTIMIZE`
-
-# 결과 보고 형식
-
-- 컴포넌트화 결과: 기존->신규 매핑, 공통 Props 계약
-- Hook 분리 결과: Hook 이름, 입력/출력, 부수효과 정책
-- 성능 결과: 전/후 지표와 측정 조건
-- 남은 리팩터 항목: 우선순위와 예상 영향
-
-# 중단 조건
-
-- 시각적 회귀가 차단 이슈 수준으로 발생한 경우
-- 컴포넌트 계약이 확정되지 않아 호출부 정리가 불가능한 경우
-- 전/후 성능 비교가 불가능해 개선 효과를 증명할 수 없는 경우
-
-# 품질 규칙
-
-- 단계별 전후 지표를 Artifact에 남긴다.
-- 계약 없는 리팩터링 금지

package/antigravity/skills/incident-response/SKILL.md

@@ -1,35 +0,0 @@
----
-name: incident-response
-description: 장애 대응, 근본 원인 수정, 재발 방지까지 수행한다. 운영 장애 및 핫픽스 대응에서 사용한다.
----
-
-# 시작 전 체크리스트
-
-- 장애 심각도(SEV), 영향 범위, 시작 시각을 확정한다.
-- 즉시 복구 경로(롤백/우회/트래픽 차단)를 준비한다.
-- 커뮤니케이션 채널과 의사결정 책임자를 지정한다.
-- 로그/메트릭/알림 스냅샷을 보존한다.
-
-# 실행 절차
-
-1. `CMD-INCIDENT-TRIAGE`로 복구 우선
-2. `CMD-IMPROVE-TECHDEBT`로 근본 원인 보완
-3. `CMD-DOC-HANDOFF`로 재발 방지 문서화
-
-# 결과 보고 형식
-
-- 타임라인: 탐지->완화->복구 시각
-- 복구 조치: 실행 명령/설정 변경/결과
-- 근본 원인: 기술 원인, 프로세스 원인
-- 재발 방지 액션: 담당자, 마감일, 검증 방법
-
-# 중단 조건
-
-- 고객 영향이 지속되는데 복구 경로가 없는 경우
-- 데이터 손상 가능성이 있어 즉시 격리가 필요한 경우
-- 재발 방지 액션의 책임자/기한이 확정되지 않은 경우
-
-# 품질 규칙
-
-- RCA와 재발 방지 액션 없는 종료 금지
-- 복구와 개선을 분리 보고

package/antigravity/skills/security-hardening/SKILL.md

@@ -1,35 +0,0 @@
----
-name: security-hardening
-description: 위협 모델링과 취약점 감사를 수행하고 보완 및 재검증까지 실행한다. 보안 강화 요청에서 사용한다.
----
-
-# 시작 전 체크리스트
-
-- 신뢰 경계와 보호 대상 자산을 확정한다.
-- 의존성 목록과 현재 취약점 현황을 수집한다.
-- 위협 모델링 범위(인증/인가/데이터/운영)를 고정한다.
-- 예외 승인 정책(책임자, 만료일)을 준비한다.
-
-# 실행 절차
-
-1. `WF-SECURITY-HARDENING` 실행
-2. `CMD-SEC-THREAT-MODEL`, `CMD-SEC-DEPENDENCY-AUDIT` 수행
-3. 보완 반영 후 테스트/리뷰 재실행
-
-# 결과 보고 형식
-
-- 위협/취약점 목록: 심각도, 영향, 우선순위
-- 보완 적용 내역: 코드/설정 변경과 근거
-- 재검증 결과: 스캔/테스트/리뷰 결과
-- 잔여 위험 및 예외 승인: 책임자, 만료일
-
-# 중단 조건
-
-- 치명 취약점이 남아 있는데 배포를 진행하려는 경우
-- 고위험 위협에 대한 완화 통제가 정의되지 않은 경우
-- 예외 승인이 만료일 없이 요청된 경우
-
-# 품질 규칙
-
-- 치명 취약점 0건 전까지 종료 금지
-- 예외 수용은 만료일 포함

package/antigravity/skills/service-lifecycle-orchestration/SKILL.md

@@ -1,36 +0,0 @@
----
-name: service-lifecycle-orchestration
-description: Plan-Implement-Test-Review-Release 흐름을 Manager 중심으로 실행한다. 신규 서비스 구축 및 대형 기능 출시에 사용한다.
----
-
-# 시작 전 체크리스트
-
-- 요구사항/ADR/범위/비범위를 확정한다.
-- 각 단계 책임 역할과 승인자를 지정한다.
-- 단계별 진입/종료 기준을 작업 시작 전에 확인한다.
-- 리스크와 롤백 전략을 초기 단계에서 기록한다.
-
-# 실행 절차
-
-1. `WF-SERVICE-E2E`를 선택한다.
-2. 단계별 입력 Artifact 스키마를 검증한다.
-3. 해당 단계 에이전트가 명령 ID를 수행한다.
-4. 출력 Artifact 검증 후 다음 단계로 진행한다.
-
-# 결과 보고 형식
-
-- 단계 상태: 완료/미완료/차단요인
-- 실행 근거: 단계별 명령 ID와 결과
-- 품질 상태: 테스트/보안/리뷰 게이트 결과
-- 다음 행동: 담당자, 마감 조건, 선행 조건
-
-# 중단 조건
-
-- 진입 기준이 충족되지 않은 단계가 있는 경우
-- 차단 이슈가 해결되지 않았는데 다음 단계로 이동하려는 경우
-- 롤백 전략 없이 배포 단계 진입이 요청된 경우
-
-# 품질 규칙
-
-- Artifact 검증 실패 시 단계 진행 금지
-- command ID 없는 임의 실행 금지