create-harness-cli 0.1.0

package/dist/prompts.js

@@ -0,0 +1,85 @@
+import * as p from '@clack/prompts';
+const MODULE_LABELS = {
+    'design-system': '토큰 스켈레톤 + stylelint(색상 원시값 차단) + 스토리 템플릿',
+    'auth-http': 'axios 인터셉터(토큰 첨부·refresh·401) + ProtectedRoute',
+    'data-fetching': 'queries 3계층 샘플 + IApiResponse + Zustand 스토어',
+    lint: '명명 규칙·import 경계 ESLint 조각 + prettier + commitlint',
+};
+const MODULE_ORDER = [
+    'design-system',
+    'auth-http',
+    'data-fetching',
+    'lint',
+];
+export const runPrompts = async (detected, defaults, suggestions) => {
+    if (defaults.yes)
+        return defaults;
+    p.intro('create-harness');
+    p.log.info([
+        `프로젝트: ${detected.projectName}`,
+        `감지: ${[
+            detected.isReact ? 'React' : null,
+            detected.isVite ? 'Vite' : null,
+            detected.isTypeScript ? 'TypeScript' : null,
+            detected.hasAxios ? 'axios' : null,
+            detected.hasTanstackQuery ? 'TanStack Query' : null,
+            detected.hasZustand ? 'Zustand' : null,
+            detected.hasTailwind ? 'Tailwind' : null,
+            detected.hasCssInJs ? 'CSS-in-JS' : null,
+        ]
+            .filter(Boolean)
+            .join(' · ')}`,
+    ].join('\n'));
+    if (detected.existingAgentFiles.length > 0) {
+        p.log.warn(`이미 존재하는 에이전트 파일: ${detected.existingAgentFiles.join(', ')}\n` +
+            '내용이 다른 파일은 덮어쓰지 않고 .harness/incoming/ 아래에 둡니다.');
+    }
+    const agents = await p.multiselect({
+        message: '어떤 에이전트를 대상으로 하나요?',
+        options: [
+            { value: 'cursor', label: 'Cursor' },
+            { value: 'claude', label: 'Claude Code' },
+        ],
+        initialValues: defaults.agents,
+        required: true,
+    });
+    if (p.isCancel(agents)) {
+        p.cancel('취소되었습니다.');
+        process.exit(1);
+    }
+    const suggestionByModule = new Map(suggestions.map((suggestion) => [suggestion.module, suggestion]));
+    const modules = await p.multiselect({
+        message: '어떤 모듈을 포함하나요? (코어 규칙·워크플로·게이트는 항상 포함)',
+        options: MODULE_ORDER.map((module) => {
+            const suggestion = suggestionByModule.get(module);
+            const mark = suggestion?.isRecommended ? '' : ' (비권장)';
+            return {
+                value: module,
+                label: `${module}${mark}`,
+                hint: suggestion
+                    ? `${MODULE_LABELS[module]} — ${suggestion.reason}`
+                    : MODULE_LABELS[module],
+            };
+        }),
+        initialValues: defaults.modules,
+        required: false,
+    });
+    if (p.isCancel(modules)) {
+        p.cancel('취소되었습니다.');
+        process.exit(1);
+    }
+    p.log.info([
+        'ponytail — 이 하네스와 무관한 서드파티 규칙(YAGNI 사다리, 최소 구현 강제).',
+        'Cursor: 최신 릴리스에서 규칙 파일을 받아 자동 설치합니다.',
+        'Claude Code: 플러그인 설치 명령 두 줄을 마지막에 안내합니다 (직접 실행 필요).',
+    ].join('\n'));
+    const ponytail = await p.confirm({
+        message: 'ponytail도 함께 설정할까요?',
+        initialValue: defaults.ponytail,
+    });
+    if (p.isCancel(ponytail)) {
+        p.cancel('취소되었습니다.');
+        process.exit(1);
+    }
+    return { ...defaults, agents, modules, ponytail };
+};

package/dist/registry.js

@@ -0,0 +1,334 @@
+import { readdirSync } from 'node:fs';
+import path from 'node:path';
+import { getTemplatesRoot, loadTemplate, parseFrontmatter, serializeFrontmatter, } from './render.js';
+const PM_RUN = {
+    npm: 'npm run',
+    pnpm: 'pnpm run',
+    yarn: 'yarn',
+    bun: 'bun run',
+};
+const PM_EXEC = {
+    npm: 'npx',
+    pnpm: 'pnpm exec',
+    yarn: 'yarn',
+    bun: 'bunx',
+};
+/**
+ * 기존 CSS에 색상 원시값이 남아 있으면 그 파일들만 유예 목록에 넣는다.
+ * 전부 error면 첫 커밋부터 막혀 게이트를 꺼버리게 되고,
+ * 전부 warning이면 새 코드의 드리프트를 못 막는다 — 목록으로 끊는다.
+ */
+export const hasStylelintBaseline = (detected, options) => options.modules.includes('design-system') &&
+    detected.cssFilesWithRawColor.length > 0;
+export const buildVars = (detected, options) => ({
+    PROJECT_NAME: detected.projectName,
+    PM: detected.packageManager,
+    PM_RUN: PM_RUN[detected.packageManager],
+    PM_EXEC: PM_EXEC[detected.packageManager],
+    RULES_DIR: options.agents.includes('cursor')
+        ? '.cursor/rules'
+        : 'docs/conventions',
+    DESIGN_SYSTEM: String(options.modules.includes('design-system')),
+    STYLELINT_BASELINE: String(hasStylelintBaseline(detected, options)),
+    CSS_RAW_COLOR_FILES: String(detected.cssFilesWithRawColor.length),
+});
+/**
+ * 대상 프로젝트의 package.json scripts를 보고 실제 존재하는 체크만 담는다.
+ * 없는 스크립트를 참조해 게이트가 즉시 깨지는 일을 막기 위함이다.
+ * 빠른 실패 순서: typecheck → lint → stylelint → test → build
+ */
+export const buildChecks = (detected, options) => {
+    const run = PM_RUN[detected.packageManager];
+    const exec = PM_EXEC[detected.packageManager];
+    const checks = [];
+    if (detected.scripts['typecheck']) {
+        checks.push({ id: 'typecheck', command: `${run} typecheck` });
+    }
+    else if (detected.isTypeScript) {
+        checks.push({ id: 'typecheck', command: `${exec} tsc --noEmit` });
+    }
+    if (detected.scripts['lint']) {
+        checks.push({ id: 'lint', command: `${run} lint` });
+    }
+    if (options.modules.includes('design-system')) {
+        checks.push({
+            id: 'stylelint',
+            command: `${exec} stylelint "src/**/*.css"`,
+        });
+    }
+    const testScript = detected.scripts['test'];
+    if (testScript) {
+        const isWatchByDefault = testScript.includes('vitest') && !/\b(run|--run)\b/.test(testScript);
+        checks.push({
+            id: 'test',
+            command: isWatchByDefault ? `${run} test -- --run` : `${run} test`,
+        });
+    }
+    if (detected.scripts['build']) {
+        checks.push({ id: 'build', command: `${run} build` });
+    }
+    return checks;
+};
+const listTemplates = (relDir) => readdirSync(path.join(getTemplatesRoot(), relDir))
+    .filter((name) => !name.startsWith('.'))
+    .sort();
+/** 해당 모듈을 빼면 그 모듈을 전제하는 규칙 정본도 같이 뺀다 */
+const RULE_MODULE_REQUIREMENT = {
+    '30-design-system.md': 'design-system',
+};
+/** templates/core/conventions/*.md → .cursor/rules/*.mdc (또는 docs/conventions/*.md) */
+const buildRuleActions = (options, vars) => listTemplates('core/conventions')
+    .filter((file) => {
+    const required = RULE_MODULE_REQUIREMENT[file];
+    return !required || options.modules.includes(required);
+})
+    .map((file) => {
+    const raw = loadTemplate(`core/conventions/${file}`, vars);
+    if (options.agents.includes('cursor')) {
+        const { meta, body } = parseFrontmatter(raw);
+        return {
+            dest: `.cursor/rules/${file.replace(/\.md$/, '.mdc')}`,
+            content: serializeFrontmatter(meta) + body,
+            module: 'core',
+        };
+    }
+    // Cursor 미선택 시에는 규칙을 docs/conventions/ 아래 일반 문서로 둔다
+    return {
+        dest: `docs/conventions/${file}`,
+        content: raw,
+        module: 'core',
+    };
+});
+const BASE_WORKFLOWS = ['spec', 'impl', 'verify', 'ship'];
+const DESIGN_SYSTEM_WORKFLOWS = ['ds-init', 'ds-add'];
+/** templates/core/workflows → .cursor/commands + .claude/skills(SKILL.md) fan-out */
+const buildWorkflowActions = (options, vars) => {
+    const actions = [];
+    const parsed = new Map();
+    // 디자인시스템 워크플로는 토큰·스토리 템플릿을 전제한다 — 모듈이 빠지면 함께 뺀다
+    const hasDesignSystem = options.modules.includes('design-system');
+    const workflows = hasDesignSystem
+        ? [...BASE_WORKFLOWS, ...DESIGN_SYSTEM_WORKFLOWS]
+        : BASE_WORKFLOWS;
+    for (const name of workflows) {
+        parsed.set(name, parseFrontmatter(loadTemplate(`core/workflows/${name}.md`, vars)));
+    }
+    if (options.agents.includes('cursor')) {
+        for (const name of workflows) {
+            const { body } = parsed.get(name);
+            actions.push({
+                dest: `.cursor/commands/${name}.md`,
+                content: body,
+                module: 'core',
+            });
+        }
+    }
+    if (options.agents.includes('claude')) {
+        // spec / impl / verify / ship 은 1:1 스킬
+        for (const name of BASE_WORKFLOWS) {
+            const { meta, body } = parsed.get(name);
+            actions.push({
+                dest: `.claude/skills/${name}/SKILL.md`,
+                content: serializeFrontmatter({
+                    name,
+                    description: meta['description'] ?? '',
+                }) + body,
+                module: 'core',
+            });
+        }
+        // design-system 스킬 하나가 ds-init·ds-add 두 흐름을 포함한다
+        if (hasDesignSystem) {
+            const dsInit = parsed.get('ds-init');
+            const dsAdd = parsed.get('ds-add');
+            actions.push({
+                dest: '.claude/skills/design-system/SKILL.md',
+                content: serializeFrontmatter({
+                    name: 'design-system',
+                    description: 'Design system workflows: one-time Storybook setup (ds-init) and adding components before layout work (ds-add).',
+                }) +
+                    `# Design System\n\n## Part 1 — ds-init (최초 1회 설정)\n\n${dsInit.body}\n\n---\n\n## Part 2 — ds-add (UI 작업마다)\n\n${dsAdd.body}`,
+                module: 'core',
+            });
+        }
+    }
+    return actions;
+};
+const buildGateActions = (options, vars) => {
+    const actions = [
+        {
+            dest: '.harness/gates/pre-commit-gate.sh',
+            content: loadTemplate('core/gates/pre-commit-gate.sh', vars),
+            module: 'core',
+            executable: true,
+        },
+        {
+            dest: '.harness/gates/gate.mjs',
+            content: loadTemplate('core/gates/gate.mjs', vars),
+            module: 'core',
+        },
+        {
+            dest: '.harness/gates/run-checks.mjs',
+            content: loadTemplate('core/gates/run-checks.mjs', vars),
+            module: 'core',
+        },
+    ];
+    if (options.agents.includes('cursor')) {
+        actions.push({
+            dest: '.cursor/hooks.json',
+            content: loadTemplate('core/gates/cursor-hooks.json', vars),
+            module: 'core',
+        });
+    }
+    if (options.agents.includes('claude')) {
+        actions.push({
+            dest: '.claude/settings.json',
+            content: loadTemplate('core/gates/claude-settings.json', vars),
+            module: 'core',
+        });
+    }
+    return actions;
+};
+const buildDocActions = (vars) => [
+    ...['architecture.md', 'decisions.md', 'product-spec.md', 'task-log.md'].map((file) => ({
+        dest: `docs/${file}`,
+        content: loadTemplate(`core/docs/${file}`, vars),
+        module: 'core',
+    })),
+    {
+        dest: 'docs/specs/_template.md',
+        content: loadTemplate('core/docs/specs/_template.md', vars),
+        module: 'core',
+    },
+];
+const buildModuleActions = (detected, options, vars) => {
+    const actions = [];
+    const preset = `presets/${options.preset}`;
+    if (options.modules.includes('design-system')) {
+        if (hasStylelintBaseline(detected, options)) {
+            actions.push({
+                dest: '.harness/stylelint-baseline.json',
+                content: JSON.stringify(detected.cssFilesWithRawColor, null, 4) + '\n',
+                module: 'design-system',
+            });
+        }
+        actions.push({
+            dest: 'src/design-system/tokens.css',
+            content: loadTemplate(`${preset}/design-system/tokens.css`, vars),
+            module: 'design-system',
+        }, {
+            dest: 'src/design-system/tokens.ts',
+            content: loadTemplate(`${preset}/design-system/tokens.ts`, vars),
+            module: 'design-system',
+        }, {
+            // .stories. 를 파일명에 넣지 않는다 — Storybook 테스트 러너의
+            // *.stories.* glob이 참고용 템플릿을 실제로 실행하려 든다
+            dest: 'src/design-system/_story-template.tsx',
+            content: loadTemplate(`${preset}/design-system/_story-template.tsx`, vars),
+            module: 'design-system',
+        }, {
+            dest: 'stylelint.config.js',
+            content: loadTemplate(`${preset}/design-system/stylelint.config.js`, vars),
+            module: 'design-system',
+        });
+    }
+    if (options.modules.includes('auth-http')) {
+        actions.push({
+            dest: 'src/utils/axiosInstance.ts',
+            content: loadTemplate(`${preset}/reference/auth-http/axiosInstance.ts`, vars),
+            module: 'auth-http',
+        }, {
+            dest: 'src/components/shared/ProtectedRoute.tsx',
+            content: loadTemplate(`${preset}/reference/auth-http/ProtectedRoute.tsx`, vars),
+            module: 'auth-http',
+        });
+    }
+    if (options.modules.includes('data-fetching')) {
+        actions.push({
+            dest: 'src/types/api.ts',
+            content: loadTemplate(`${preset}/reference/data-fetching/api.ts`, vars),
+            module: 'data-fetching',
+        }, {
+            dest: 'src/queries/Example/exampleApi.ts',
+            content: loadTemplate(`${preset}/reference/data-fetching/exampleApi.ts`, vars),
+            module: 'data-fetching',
+        }, {
+            dest: 'src/queries/Example/exampleQueryKeys.ts',
+            content: loadTemplate(`${preset}/reference/data-fetching/exampleQueryKeys.ts`, vars),
+            module: 'data-fetching',
+        }, {
+            dest: 'src/queries/Example/index.ts',
+            content: loadTemplate(`${preset}/reference/data-fetching/index.ts`, vars),
+            module: 'data-fetching',
+        }, {
+            dest: 'src/stores/shared/alertDialogStore.ts',
+            content: loadTemplate(`${preset}/reference/data-fetching/alertDialogStore.ts`, vars),
+            module: 'data-fetching',
+        });
+    }
+    if (options.modules.includes('lint')) {
+        actions.push({
+            dest: 'eslint.harness.config.js',
+            content: loadTemplate(`${preset}/configs/eslint.harness.config.js`, vars),
+            module: 'lint',
+        }, {
+            dest: 'commitlint.config.js',
+            content: loadTemplate(`${preset}/configs/commitlint.config.js`, vars),
+            module: 'lint',
+        }, {
+            dest: 'prettier.config.js',
+            content: loadTemplate(`${preset}/configs/prettier.config.js`, vars),
+            module: 'lint',
+        });
+    }
+    return actions;
+};
+/** 스캐폴딩으로 생성할 전체 파일 목록을 만든다 (manifest.json 제외 — 마지막에 별도 기록) */
+export const buildPlan = (detected, options) => {
+    const vars = buildVars(detected, options);
+    const config = {
+        packageManager: detected.packageManager,
+        checks: buildChecks(detected, options),
+    };
+    const actions = [
+        {
+            dest: 'AGENTS.md',
+            content: loadTemplate('core/AGENTS.md', vars),
+            module: 'core',
+        },
+        {
+            dest: '.harness/config.json',
+            content: JSON.stringify(config, null, 4) + '\n',
+            module: 'core',
+        },
+        ...buildRuleActions(options, vars),
+        ...buildWorkflowActions(options, vars),
+        ...buildGateActions(options, vars),
+        ...buildDocActions(vars),
+        ...buildModuleActions(detected, options, vars),
+    ];
+    if (options.agents.includes('claude')) {
+        actions.splice(1, 0, {
+            dest: 'CLAUDE.md',
+            content: loadTemplate('core/CLAUDE.md', vars),
+            module: 'core',
+        });
+    }
+    return actions;
+};
+/** 선택 모듈이 요구하는 devDependencies (자동 설치하지 않고 안내 출력용) */
+export const requiredDevDeps = (options) => {
+    const deps = [];
+    if (options.modules.includes('design-system')) {
+        deps.push('stylelint', 'stylelint-declaration-strict-value');
+    }
+    if (options.modules.includes('lint')) {
+        deps.push('eslint-plugin-import', '@commitlint/cli', '@commitlint/config-conventional', 'prettier');
+    }
+    if (options.modules.includes('data-fetching')) {
+        deps.push('@tanstack/react-query', 'zustand');
+    }
+    if (options.modules.includes('auth-http')) {
+        deps.push('axios', 'react-router-dom');
+    }
+    return [...new Set(deps)];
+};

package/dist/render.js

@@ -0,0 +1,43 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * 렌더러의 소스 루트는 templates/ 하나로 하드코딩한다.
+ * 저장소 루트의 TODO.md·DECISIONS.md 같은 내부 기록이
+ * 대상 프로젝트로 복사될 경로가 애초에 존재하지 않게 하기 위함이다.
+ */
+export const getTemplatesRoot = () => path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'templates');
+/**
+ * `{{#if FLAG}}...{{/if}}` 블록. 플래그가 'true' 가 아니면 블록 전체를 지운다.
+ * 모듈을 빼면 그 모듈을 참조하는 규칙 문장도 같이 빠져야 하기 때문에 필요하다
+ * (존재하지 않는 파일을 가리키는 규칙은 에이전트를 헷갈리게 한다).
+ * 블록이 줄 전체를 차지하면 남는 빈 줄까지 함께 제거한다.
+ */
+const applyConditionals = (content, vars) => content.replace(/[ \t]*\{\{#if ([A-Z0-9_]+)\}\}\n?([\s\S]*?)[ \t]*\{\{\/if\}\}\n?/g, (_match, key, block) => vars[key] === 'true' ? block : '');
+export const renderString = (content, vars) => applyConditionals(content, vars).replace(/\{\{([A-Z0-9_]+)\}\}/g, (match, key) => (key in vars ? vars[key] : match));
+/** templates/ 기준 상대 경로의 템플릿을 읽어 변수 치환까지 마친 문자열을 돌려준다 */
+export const loadTemplate = (relPath, vars) => renderString(readFileSync(path.join(getTemplatesRoot(), relPath), 'utf-8'), vars);
+/**
+ * `---` 로 감싼 단순 frontmatter 파서.
+ * `key: value` 한 줄 형식만 지원한다 (템플릿 정본에는 그 이상이 필요 없다).
+ */
+export const parseFrontmatter = (content) => {
+    const match = /^---\n([\s\S]*?)\n---\n?/.exec(content);
+    if (!match)
+        return { meta: {}, body: content };
+    const meta = {};
+    for (const line of match[1].split('\n')) {
+        const idx = line.indexOf(':');
+        if (idx === -1)
+            continue;
+        const key = line.slice(0, idx).trim();
+        const value = line.slice(idx + 1).trim();
+        if (key)
+            meta[key] = value;
+    }
+    return { meta, body: content.slice(match[0].length) };
+};
+export const serializeFrontmatter = (meta) => {
+    const lines = Object.entries(meta).map(([key, value]) => `${key}: ${value}`);
+    return `---\n${lines.join('\n')}\n---\n`;
+};

package/dist/suggest.js

@@ -0,0 +1,114 @@
+/**
+ * 감지 결과로 모듈 기본 선택값을 정한다.
+ *
+ * 기준은 하나다: **생성 직후 대상 프로젝트에서 그대로 컴파일·통과하는가.**
+ * 참조 구현은 특정 라이브러리(axios·TanStack Query 등)를 전제하므로,
+ * 그 전제가 없는 프로젝트에 기본으로 넣으면 typecheck가 즉시 깨진다.
+ * 비추천이어도 사용자가 프롬프트나 --modules 로 직접 켤 수 있다.
+ */
+export const suggestModules = (detected) => [
+    suggestDesignSystem(detected),
+    suggestAuthHttp(detected),
+    suggestDataFetching(detected),
+    suggestLint(detected),
+];
+export const recommendedModules = (detected) => suggestModules(detected)
+    .filter((suggestion) => suggestion.isRecommended)
+    .map((suggestion) => suggestion.module);
+const suggestDesignSystem = (detected) => {
+    // stylelint 색상 강제는 CSS 선언을 검사한다. Tailwind는 유틸리티 클래스라 검사 대상이
+    // 거의 없고, CSS-in-JS는 값이 TS 안에 있어 stylelint가 아예 보지 못한다.
+    // 강제할 수 없는데 켜두면 "지켜지고 있다"는 착각만 준다.
+    if (detected.hasTailwind) {
+        return {
+            module: 'design-system',
+            isRecommended: false,
+            reason: 'Tailwind 감지 — 토큰 강제가 불가능합니다 (하네스는 CSS Modules + 토큰을 권장)',
+        };
+    }
+    if (detected.hasCssInJs) {
+        return {
+            module: 'design-system',
+            isRecommended: false,
+            reason: 'CSS-in-JS 감지 — 색상값이 TS 안에 있어 stylelint가 검사하지 못합니다',
+        };
+    }
+    return {
+        module: 'design-system',
+        isRecommended: true,
+        reason: 'CSS / CSS Modules 프로젝트로 판단',
+    };
+};
+const suggestAuthHttp = (detected) => {
+    const missing = [];
+    if (!detected.hasAxios)
+        missing.push('axios');
+    if (!detected.hasReactRouter)
+        missing.push('react-router');
+    if (missing.length > 0) {
+        return {
+            module: 'auth-http',
+            isRecommended: false,
+            reason: `${missing.join('·')} 없음 — 참조 구현이 컴파일되지 않습니다`,
+        };
+    }
+    if (!detected.isVite) {
+        return {
+            module: 'auth-http',
+            isRecommended: false,
+            reason: 'Vite 아님 — 참조 구현이 import.meta.env.VITE_* 를 씁니다',
+        };
+    }
+    return {
+        module: 'auth-http',
+        isRecommended: true,
+        reason: 'axios + react-router + Vite 감지',
+    };
+};
+const suggestDataFetching = (detected) => {
+    const missing = [];
+    if (!detected.hasTanstackQuery)
+        missing.push('@tanstack/react-query');
+    if (!detected.hasZustand)
+        missing.push('zustand');
+    if (missing.length > 0) {
+        return {
+            module: 'data-fetching',
+            isRecommended: false,
+            reason: `${missing.join('·')} 없음 — 참조 구현이 컴파일되지 않습니다`,
+        };
+    }
+    if (!detected.hasAxios) {
+        return {
+            module: 'data-fetching',
+            isRecommended: false,
+            reason: 'axios 없음 — queries 샘플이 axiosInstance 를 씁니다',
+        };
+    }
+    return {
+        module: 'data-fetching',
+        isRecommended: true,
+        reason: 'TanStack Query + Zustand 감지',
+    };
+};
+const suggestLint = (detected) => {
+    if (!detected.hasEslintFlatConfig) {
+        return {
+            module: 'lint',
+            isRecommended: false,
+            reason: 'ESLint flat config(eslint.config.*) 없음 — 규칙 조각을 spread할 대상이 없습니다',
+        };
+    }
+    if (!detected.isTypeScript) {
+        return {
+            module: 'lint',
+            isRecommended: false,
+            reason: 'TypeScript 아님 — 명명 규칙이 타입 정보를 요구합니다',
+        };
+    }
+    return {
+        module: 'lint',
+        isRecommended: true,
+        reason: 'ESLint flat config + TypeScript 감지',
+    };
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,48 @@
+{
+    "name": "create-harness-cli",
+    "version": "0.1.0",
+    "description": "Scaffold AI coding agent harness (conventions, verification gates, workflows) onto an existing project — for Cursor and Claude Code.",
+    "type": "module",
+    "bin": {
+        "create-harness-cli": "./dist/cli.js"
+    },
+    "files": [
+        "dist",
+        "templates"
+    ],
+    "engines": {
+        "node": ">=20.0.0"
+    },
+    "scripts": {
+        "build": "tsc -p tsconfig.json",
+        "dev": "tsx src/cli.ts",
+        "typecheck": "tsc --noEmit -p tsconfig.json",
+        "test": "vitest run",
+        "check": "npm run typecheck && npm run build && npm run test"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/ysh038/create-harness.git"
+    },
+    "keywords": [
+        "ai",
+        "agent",
+        "harness",
+        "scaffold",
+        "cursor",
+        "claude-code",
+        "agents-md",
+        "cli"
+    ],
+    "license": "MIT",
+    "dependencies": {
+        "@clack/prompts": "^1.7.0",
+        "picocolors": "^1.1.1"
+    },
+    "devDependencies": {
+        "@types/node": "^26.1.2",
+        "tsx": "^4.23.1",
+        "typescript": "^7.0.2",
+        "vitest": "^3.2.7"
+    }
+}

package/templates/core/AGENTS.md

@@ -0,0 +1,55 @@
+# {{PROJECT_NAME}} — Agent Guide
+
+> 이 파일은 모든 AI 에이전트(Cursor, Claude Code 등)가 항상 읽는 정본이다.
+> 짧게 유지한다. 상세 규칙은 `{{RULES_DIR}}/` 에 있고, 해당 파일을 만질 때 로드된다.
+
+## 프로젝트 개요
+
+<!-- TODO: 한 문단으로 채우세요. 무엇을 하는 서비스이고, 핵심 도메인 용어는 무엇인지 -->
+
+## 자주 쓰는 명령어
+
+```bash
+{{PM_RUN}} dev          # 개발 서버
+node .harness/gates/run-checks.mjs   # 전체 검증 (.harness/config.json 의 checks 순차 실행)
+```
+
+## 검증 게이트
+
+- 커밋 전 **반드시** `node .harness/gates/run-checks.mjs` 가 통과해야 한다.
+  커밋 게이트(`.harness/gates/pre-commit-gate.sh`)가 실패 시 커밋을 거부한다.
+- 검증 목록은 `.harness/config.json` 의 `checks` 배열이다. 체크를 추가/제거하려면 이 파일을 수정한다.
+- 테스트를 통과시키기 위해 단정문(assertion)을 약화시키지 않는다. 실패하면 코드를 고친다.
+
+## 워크플로
+
+| 커맨드 | 용도 |
+|--------|------|
+| `/spec <기능>` | 구현 전 명세 작성 (`docs/specs/`) — 수용 기준은 테스트로 번역 가능해야 함 |
+| `/impl <slug>` | 명세 기반 구현 — 실패하는 테스트 먼저 (Red → Green → Refactor) |
+| `/verify` | checks 순차 실행, 실패 시 수정 루프 |
+| `/ship` | 검증 → 커밋 → `docs/task-log.md` 기록 |
+{{#if DESIGN_SYSTEM}}| `/ds-init` | Storybook 온디맨드 설치 (최초 UI 작업 전 1회) |
+| `/ds-add` | 레이아웃 착수 전 디자인시스템 컴포넌트 + 스토리 선행 추가 |
+{{/if}}
+
+## 절대 금지
+
+| 금지 | 이유 |
+|------|------|
+| `any` 타입 | 타입 안전성 포기. `unknown` + 좁히기를 쓴다 |
+| `git commit --no-verify` | 게이트 우회 금지 |
+| `git push --force` (보호 브랜치) | 이력 파괴. 필요하면 `--force-with-lease` + 사전 협의 |
+| `.env*` 파일 커밋 | 시크릿 유출 |
+| 라우트(페이지) 컴포넌트에 비즈니스 로직 | hooks/queries 레이어로 내린다 (`{{RULES_DIR}}/10-architecture` 참고) |
+{{#if DESIGN_SYSTEM}}| CSS 색상 원시값 (`#hex`, `rgb()`) | 디자인 토큰만 사용. stylelint가 error 처리 |
+{{/if}}| 테스트 단정문 약화로 통과시키기 | 검증의 의미가 사라진다 |
+
+## 장기 기억 문서
+
+| 파일 | 용도 |
+|------|------|
+| `docs/architecture.md` | 구조가 바뀔 때 갱신 |
+| `docs/decisions.md` | 결정과 **근거** (결론만 적지 않는다) |
+| `docs/product-spec.md` | 기능 명세 + TODO 목록 |
+| `docs/task-log.md` | `/ship` 시 자동 기록 |