@ps-neko/nekowork 0.1.0-alpha.0

package/agents/research.md

@@ -0,0 +1,50 @@
+---
+name: research
+description: "외부 정보 수집. Context7 / Exa / GitHub 검색. read-only."
+provider: gemini
+model: gemini-2.5-pro
+level: 1
+disallowedTools: [Write, Edit, Bash]
+trigger: ["research", "찾아봐", "검색", "조사"]
+hand_off_to: [planner, architect]
+sandbox: read-only
+---
+
+# Research
+
+장컨텍스트 / 다중 출처 통합이 필요한 리서치를 Gemini CLI 워커로 위임. Anthropic 토큰 0.
+
+## 사용 우선순위 (사용자 룰)
+
+1. **GitHub code search 먼저** — 기존 구현 / 템플릿
+2. **라이브러리 공식 문서** — Context7 MCP
+3. **Exa** — 위 둘이 부족할 때만
+
+## 출력
+
+```markdown
+## 발견
+- [출처 1] (URL · 신뢰도)
+- [출처 2]
+
+## 채택 후보
+- 라이브러리 X (왜): ...
+- 패턴 Y (왜): ...
+
+## 거절안
+- ...
+
+## 미해결 / 모호
+- ...
+```
+
+## 금지
+
+- 출처 없는 주장 금지. 모든 사실 주장은 URL 또는 file:line 인용.
+- "GPT 가 그렇게 말했다" 금지.
+
+## CLI 위임
+
+```bash
+gemini --no-browser --quiet < prompt.md > research-output.md
+```

package/agents/security-reviewer.md

@@ -0,0 +1,47 @@
+---
+name: security-reviewer
+description: "보안 게이트. auth / crypto / payment / 외부 API 변경 시 강제."
+provider: claude
+model: opus
+level: 3
+disallowedTools: [Write, Edit, Bash]
+trigger: ["security review", "보안 검토"]
+hand_off_to: []
+fact_forcing: true
+sandbox: read-only
+---
+
+# Security Reviewer
+
+보안 12-item Minimum Bar 기반 게이트. AGENTS.md 의 checklist 참조.
+
+## 자동 활성
+
+- 변경에 다음 디렉터리/파일 포함:
+  - `auth/`, `crypto/`, `payment/`, `session/`, `permission/`, `oauth/`, `jwt`, `password`, `secret`
+- 새 외부 API 호출
+- DB 스키마 변경
+- `.env*` 또는 시크릿 관련 파일 변경
+
+## 검토 항목 (12-item Minimum Bar)
+
+1. agent ID / 개인 계정 분리
+2. short-lived scoped credentials (OIDC)
+3. untrusted work — sandbox / devcontainer / VM
+4. outbound network deny by default
+5. secret-bearing path 읽기 차단
+6. input sanitization (파일·HTML·스크린샷·링크)
+7. unsandboxed shell / egress / deploy / off-repo write — approval
+8. tool calls / approvals / network attempts 로깅
+9. process-group kill + heartbeat dead-man switch
+10. persistent memory narrow & disposable
+11. 카탈로그(skills, hooks, MCP) 도 supply chain 스캔
+12. MCP 서버 SemVer 핀
+
+## 출력
+
+표준 핸드오프 JSON. severity = critical 1건이라도 → 즉시 human gate.
+
+## fact_forcing 강제
+
+이 에이전트는 항상 importer·public API·schema 조사를 강제한다. "Are you sure?" 자체 질문은 무력하다.

package/agents/test-engineer.md

@@ -0,0 +1,41 @@
+---
+name: test-engineer
+description: "테스트 작성 · 커버리지 · TDD 강제. 80% 게이트."
+provider: claude
+model: sonnet
+level: 2
+disallowedTools: []
+trigger: ["test", "테스트", "TDD", "커버리지"]
+hand_off_to: [executor]
+fact_forcing: false
+sandbox: workspace-write
+---
+
+# Test Engineer
+
+테스트 우선 작성. 기능 / 엣지 / 회귀 / 통합 / e2e 다층 커버.
+
+## 책임
+
+- TDD RED 단계의 실패 테스트 작성.
+- 회귀 테스트 (debugger 가 재현한 시나리오).
+- 모킹은 시스템 경계만 (DB·외부 API·시계).
+- 커버리지 80% 미달 시 게이트 차단.
+
+## 테스트 분류
+
+| 종류 | 위치 | 도구 |
+|---|---|---|
+| Unit | `tests/unit/` | node:test |
+| Integration | `tests/integration/` | node:test + 실 DB(컨테이너) |
+| E2E | `tests/e2e/` | playwright |
+
+## 금지
+
+- 모킹된 통합 테스트 (사용자 룰: "DB 모킹 금지"는 없음. 단 PoC 환경에서 실 DB 컨테이너 권장).
+- assert 없는 테스트.
+- 항상 통과하는(true == true) 테스트.
+
+## 핸드오프
+
+테스트 파일 경로 목록 + 커버리지 % + RED → GREEN 전환 카운트.

package/bridge/mcp-server.js

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+// HARNESS MCP 단일 게이트웨이.
+// 4개 도구: state_read, state_write, notepad_append, handoff_write.
+// .mcp.json 에서 단일 서버로 등록되어 외부 MCP (github, context7, exa, memory) 는 별도 namespace 로 proxy 가능.
+// 현재 4 도구만. namespace 프록시는 향후 확장.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { classifyCategory, classifySeverity, severityCounts, deriveVerdict, riskLevel } from '../scripts/lib/severity.js';
+import { decide as routeDecide } from '../scripts/lib/router.js';
+import { record as costRecord, list as costList, summarize as costSummarize } from '../scripts/lib/costs.js';
+
+const ROOT = process.env.HARNESS_ROOT || process.cwd();
+const SESSION_ID = process.env.HARNESS_SESSION_ID || 'default';
+const SESSION_DIR = path.join(ROOT, '.harness', 'state', 'sessions', SESSION_ID);
+
+function ensureSession() {
+  fs.mkdirSync(path.join(SESSION_DIR, 'handoffs'), { recursive: true });
+  fs.mkdirSync(path.join(SESSION_DIR, 'facts'), { recursive: true });
+}
+
+function audit(event, details) {
+  const auditDir = path.join(ROOT, '.harness', 'audit');
+  fs.mkdirSync(auditDir, { recursive: true });
+  const today = new Date().toISOString().slice(0, 10);
+  const f = path.join(auditDir, `${today}.jsonl`);
+  fs.appendFileSync(f, JSON.stringify({
+    ts: new Date().toISOString(),
+    session: SESSION_ID,
+    event,
+    ...details,
+  }) + '\n');
+}
+
+const TOOLS = [
+  {
+    name: 'state_read',
+    description: '세션 상태 파일 읽기. notepad / prd / progress / round / 임의 키 지원.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        key: { type: 'string', description: 'notepad | prd | progress | round | <상대경로>' },
+      },
+      required: ['key'],
+    },
+  },
+  {
+    name: 'state_write',
+    description: '세션 상태 파일 쓰기 (덮어씀). prd / round / 임의 JSON 키.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        key: { type: 'string' },
+        value: { description: '문자열 또는 JSON 직렬화 가능 객체' },
+      },
+      required: ['key', 'value'],
+    },
+  },
+  {
+    name: 'notepad_append',
+    description: '세션 notepad.md 에 라인 추가 (append).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        line: { type: 'string' },
+      },
+      required: ['line'],
+    },
+  },
+  {
+    name: 'handoff_write',
+    description: '단계별 핸드오프 작성. handoffs/<NN>-<stage>.md. 5필드 강제.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        stage: { enum: ['ideate', 'plan', 'implement', 'self-review', 'codex-review', 'codex-challenge', 'ship'] },
+        agent: { type: 'string' },
+        round: { type: 'integer', minimum: 1, default: 1 },
+        decided: { type: 'string' },
+        rejected: { type: 'string' },
+        risks: { type: 'string' },
+        files: { type: 'array', items: { type: 'string' } },
+        remaining: { type: 'string' },
+        issues: { type: 'array' },
+        verdict: { enum: ['block', 'approve_with_fixes', 'approve'] },
+        confidence: { type: 'number', minimum: 0, maximum: 1 },
+      },
+      required: ['stage', 'agent', 'decided', 'files'],
+    },
+  },
+  {
+    name: 'severity_classify',
+    description: '이슈 한 건 또는 이슈 배열의 severity / category 자동 분류. 명시값이 있으면 그대로, 없으면 휴리스틱.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        issues: { type: 'array', description: 'issue 객체 배열' },
+        files: { type: 'array', items: { type: 'string' } },
+        task: { type: 'string' },
+      },
+      required: ['issues'],
+    },
+  },
+  {
+    name: 'route_decide',
+    description: '단계 + task + files + eco_mode 입력 → 라우팅 결정 (agent/model/provider) 출력. routing.jsonl 에 트레이스 가능.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        stage: { type: 'string' },
+        task: { type: 'string' },
+        files: { type: 'array', items: { type: 'string' } },
+        eco_mode: { type: 'boolean' },
+        risk_level: { enum: ['low', 'medium', 'high', 'critical'] },
+        trace: { type: 'boolean', description: '결정을 routing.jsonl 에 기록' },
+      },
+      required: ['stage'],
+    },
+  },
+  {
+    name: 'cost_record',
+    description: '도구 호출 1건의 비용을 ~/.harness/costs.jsonl 에 기록. agent / stage / model / tokens / duration / 추정 USD.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        agent: { type: 'string' },
+        stage: { type: 'string' },
+        provider: { type: 'string' },
+        model: { type: 'string' },
+        input_tokens: { type: 'integer' },
+        output_tokens: { type: 'integer' },
+        duration_ms: { type: 'integer' },
+      },
+      required: ['agent', 'stage', 'model'],
+    },
+  },
+];
+
+const server = new Server(
+  { name: 'harness', version: '0.0.2' },
+  { capabilities: { tools: {} } },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  ensureSession();
+  const { name, arguments: args } = req.params;
+
+  try {
+    if (name === 'state_read') {
+      const file = mapKeyToPath(args.key);
+      if (!fs.existsSync(file)) {
+        audit('state_read.miss', { key: args.key, file });
+        return { content: [{ type: 'text', text: '' }], isError: false };
+      }
+      const data = fs.readFileSync(file, 'utf8');
+      audit('state_read', { key: args.key, file, bytes: data.length });
+      return { content: [{ type: 'text', text: data }] };
+    }
+
+    if (name === 'state_write') {
+      const file = mapKeyToPath(args.key);
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      const text = typeof args.value === 'string' ? args.value : JSON.stringify(args.value, null, 2);
+      fs.writeFileSync(file, text);
+      audit('state_write', { key: args.key, file, bytes: text.length });
+      return { content: [{ type: 'text', text: `OK ${file} (${text.length}B)` }] };
+    }
+
+    if (name === 'notepad_append') {
+      const file = path.join(SESSION_DIR, 'notepad.md');
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      const line = String(args.line).replace(/\r?\n$/, '') + '\n';
+      fs.appendFileSync(file, line);
+      audit('notepad_append', { file, bytes: line.length });
+      return { content: [{ type: 'text', text: 'OK' }] };
+    }
+
+    if (name === 'severity_classify') {
+      const enriched = (args.issues || []).map((i) => ({
+        ...i,
+        category: classifyCategory(i),
+        severity: classifySeverity(i),
+      }));
+      const counts = severityCounts(enriched);
+      const verdict = deriveVerdict(enriched);
+      const risk = riskLevel(args.files || [], args.task || '');
+      audit('severity_classify', { count: enriched.length, verdict, risk });
+      return { content: [{ type: 'text', text: JSON.stringify({ issues: enriched, counts, verdict, risk_level: risk }, null, 2) }] };
+    }
+
+    if (name === 'route_decide') {
+      const decision = routeDecide({
+        stage: args.stage,
+        task: args.task,
+        files: args.files,
+        ecoMode: args.eco_mode,
+        riskLevel: args.risk_level,
+        harnessRoot: ROOT,
+      });
+      if (args.trace) {
+        const { trace } = await import('../scripts/lib/router.js');
+        trace(SESSION_DIR, decision, { stage: args.stage, task: args.task });
+      }
+      audit('route_decide', { stage: args.stage, agent: decision.agent, model: decision.model });
+      return { content: [{ type: 'text', text: JSON.stringify(decision, null, 2) }] };
+    }
+
+    if (name === 'cost_record') {
+      const row = costRecord({
+        ts: new Date().toISOString(),
+        session: SESSION_ID,
+        stage: args.stage,
+        agent: args.agent,
+        provider: args.provider,
+        model: args.model,
+        input_tokens: args.input_tokens,
+        output_tokens: args.output_tokens,
+        duration_ms: args.duration_ms,
+      });
+      audit('cost_record', { model: row.model, usd: row.estimate_usd });
+      return { content: [{ type: 'text', text: JSON.stringify(row, null, 2) }] };
+    }
+
+    if (name === 'handoff_write') {
+      const stageOrder = ['ideate', 'plan', 'implement', 'self-review', 'codex-review', 'codex-challenge', 'ship'];
+      const idx = stageOrder.indexOf(args.stage);
+      if (idx < 0) throw new Error(`unknown stage: ${args.stage}`);
+      const nn = String(idx + 1).padStart(2, '0');
+      const file = path.join(SESSION_DIR, 'handoffs', `${nn}-${args.stage}.md`);
+
+      const md = renderHandoff(args);
+      fs.writeFileSync(file, md);
+
+      // JSON 부속도 같이 저장
+      const jsonFile = file.replace(/\.md$/, '.json');
+      fs.writeFileSync(jsonFile, JSON.stringify({
+        stage: args.stage,
+        agent: args.agent,
+        round: args.round || 1,
+        timestamp: new Date().toISOString(),
+        ...args,
+      }, null, 2));
+
+      audit('handoff_write', { stage: args.stage, agent: args.agent, file, verdict: args.verdict });
+      return { content: [{ type: 'text', text: `OK ${file} + ${path.basename(jsonFile)}` }] };
+    }
+
+    throw new Error(`unknown tool: ${name}`);
+  } catch (e) {
+    audit('error', { tool: name, message: e.message });
+    return {
+      content: [{ type: 'text', text: `ERROR: ${e.message}` }],
+      isError: true,
+    };
+  }
+});
+
+function mapKeyToPath(key) {
+  switch (key) {
+    case 'notepad':  return path.join(SESSION_DIR, 'notepad.md');
+    case 'prd':      return path.join(SESSION_DIR, 'prd.json');
+    case 'progress': return path.join(SESSION_DIR, 'progress.txt');
+    case 'round':    return path.join(SESSION_DIR, 'round.json');
+    default:
+      if (key.includes('..')) throw new Error('상위 디렉터리 접근 금지');
+      return path.join(SESSION_DIR, key);
+  }
+}
+
+function renderHandoff(a) {
+  const lines = [];
+  lines.push(`# Handoff: ${String(a.stage)}  (round ${a.round || 1}, agent: ${a.agent})`);
+  lines.push('');
+  lines.push(`**Decided**: ${a.decided}`);
+  if (a.rejected)  lines.push(`**Rejected**: ${a.rejected}`);
+  if (a.risks)     lines.push(`**Risks**: ${a.risks}`);
+  lines.push(`**Files**: ${(a.files || []).join(', ')}`);
+  if (a.remaining) lines.push(`**Remaining**: ${a.remaining}`);
+  if (a.verdict)   lines.push(`**Verdict**: ${a.verdict}${a.confidence != null ? ` (confidence ${a.confidence})` : ''}`);
+  if (a.issues && a.issues.length) {
+    lines.push('');
+    lines.push('## Issues');
+    for (const i of a.issues) {
+      lines.push(`- [${i.severity || '?'}/${i.category || '?'}] ${i.file || ''}${i.line ? ':' + i.line : ''} — ${i.summary || ''}`);
+    }
+  }
+  return lines.join('\n') + '\n';
+}
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+process.stderr.write(`[harness mcp] gateway up. session=${SESSION_ID} root=${ROOT}\n`);

package/commands/claude-led-codex-review.md

@@ -0,0 +1,29 @@
+---
+description: "Claude 주도 + Codex 위임 7단계 풀사이클. claude-led-codex-review 스킬 호출."
+---
+
+# /claude-led-codex-review
+
+이 슬래시 명령은 `claude-led-codex-review` 스킬의 legacy compat 진입점이다. 신규 워크플로우는 스킬에서 정의되지만 슬래시 호출 호환성을 위해 보존.
+
+## 동작
+
+`Skill` 도구로 `claude-led-codex-review` 를 즉시 호출. 인자가 있으면 작업 요약으로 전달, 없으면 사용자에게 한 줄 요약을 요청.
+
+## 인자
+
+- `$ARGUMENTS` — 작업 요약 한 줄
+- `--fast` — 단계 1·6 스킵
+- `--secure` — 단계 6 강제
+- `--no-ship` — 단계 7 생략
+
+## 예시
+
+```
+/claude-led-codex-review JWT 검증 미들웨어 추가 --secure
+/claude-led-codex-review 결제 환불 로직 버그 수정
+/claude-led-codex-review --fast 사소한 리팩토링
+/claude-led-codex-review 새 API 엔드포인트 --no-ship
+```
+
+전체 명세는 `skills/claude-led-codex-review/SKILL.md` 참조.