@ps-neko/nekowork 0.1.0-alpha.0

package/scripts/orchestrators/work.js

@@ -0,0 +1,207 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { dispatch } from '../agents/dispatch.js';
+import { ensureAcceptanceCriteria } from '../lib/acceptance-criteria.js';
+import { profilePolicy } from '../lib/profile-policy.js';
+import { withExecutionWorkspace } from '../core/execution-workspace.js';
+
+const STAGE_INDEX = { implement: '03' };
+
+export async function workCycle(opts) {
+  const harnessRoot = opts.harnessRoot || process.cwd();
+  const projectRoot = opts.projectRoot || harnessRoot;
+  const sessionId = opts.sessionId || `work-${Date.now()}`;
+  const sessionDir = path.join(projectRoot, '.harness', 'state', 'sessions', sessionId);
+  const handoffDir = path.join(sessionDir, 'handoffs');
+  fs.mkdirSync(handoffDir, { recursive: true });
+
+  const dispatcher = opts.dispatcher || dispatch;
+  const live = !!opts.live;
+  const priorHandoffs = readPriorHandoffs(handoffDir);
+  const prd = readJsonIfExists(path.join(sessionDir, 'prd.json'));
+  const acceptance = ensureAcceptanceCriteria({ sessionDir, task: opts.task });
+  const policy = profilePolicy(opts.profile || readSessionProfile(sessionDir));
+  const round = nextRound(priorHandoffs, 'implement');
+
+  const context = {
+    profile: policy.profile,
+    qualityChecklist: policy.checklist,
+    prd,
+    acceptanceCriteria: acceptance.criteria,
+    priorHandoffs: priorHandoffs.slice(-6),
+    acCount: acceptance.criteria.length,
+    round,
+    singleExecutor: true,
+  };
+
+  const execution = live
+    ? await runLiveExecutor({ harnessRoot, projectRoot, sessionDir, sessionId, task: opts.task, context, dispatcher, round })
+    : await runMockExecutor({ harnessRoot, projectRoot, sessionDir, sessionId, task: opts.task, context, dispatcher });
+
+  const handoff = execution.handoff;
+  if (policy.profile) handoff.profile = policy.profile;
+  handoff.round = round;
+  handoff.session_id = sessionId;
+  handoff.files = dedupe([...(handoff.files || []), ...(execution.files || [])]);
+  if (execution.diffPath) handoff.diffPath = execution.diffPath;
+  if (execution.executionWorkspace) handoff.executionWorkspace = execution.executionWorkspace;
+
+  writeHandoff(handoffDir, handoff);
+  writeSummary(sessionDir, {
+    sessionId,
+    task: opts.task,
+    live,
+    round,
+    handoff,
+    diffPath: execution.diffPath || null,
+    files: handoff.files || [],
+    acceptance,
+    profile: policy.profile,
+    qualityChecklist: policy.checklist,
+  });
+
+  return {
+    sessionId,
+    sessionDir,
+    handoff,
+    handoffs: [...priorHandoffs, handoff],
+    files: handoff.files || [],
+    diffPath: execution.diffPath || null,
+    live,
+    round,
+  };
+}
+
+async function runMockExecutor({ harnessRoot, projectRoot, sessionDir, sessionId, task, context, dispatcher }) {
+  const handoff = await dispatcher({
+    agent: 'executor',
+    stage: 'implement',
+    task,
+    live: false,
+    harnessRoot,
+    projectRoot,
+    sessionDir,
+    sessionId,
+    context,
+  });
+  return { handoff, files: [], diffPath: null, executionWorkspace: null };
+}
+
+async function runLiveExecutor({ harnessRoot, projectRoot, sessionDir, sessionId, task, context, dispatcher, round }) {
+  const execution = await withExecutionWorkspace(
+    projectRoot,
+    sessionDir,
+    async (workspaceRoot) => dispatcher({
+      agent: 'executor',
+      stage: 'implement',
+      task,
+      live: true,
+      harnessRoot,
+      projectRoot: workspaceRoot,
+      sessionDir,
+      sessionId,
+      context,
+      executionMode: 'workspace-write',
+    }),
+    { sessionId, stage: 'implement', round },
+  );
+
+  return {
+    handoff: execution.result,
+    files: execution.files,
+    diffPath: execution.diffPath,
+    executionWorkspace: execution.worktreeRoot,
+  };
+}
+
+function readPriorHandoffs(handoffDir) {
+  if (!fs.existsSync(handoffDir)) return [];
+  return fs.readdirSync(handoffDir)
+    .filter(f => f.endsWith('.json'))
+    .sort()
+    .map(f => {
+      try {
+        return JSON.parse(fs.readFileSync(path.join(handoffDir, f), 'utf8'));
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function readJsonIfExists(file) {
+  if (!fs.existsSync(file)) return null;
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; }
+}
+
+function readSessionProfile(sessionDir) {
+  return readJsonIfExists(path.join(sessionDir, 'ask.json'))?.profile || null;
+}
+
+function nextRound(handoffs, stage) {
+  const rounds = handoffs
+    .filter(h => h.stage === stage)
+    .map(h => Number(h.round || 1))
+    .filter(Number.isFinite);
+  return rounds.length ? Math.max(...rounds) + 1 : 1;
+}
+
+function writeSummary(sessionDir, summary) {
+  fs.writeFileSync(path.join(sessionDir, 'work-summary.json'), JSON.stringify({
+    sessionId: summary.sessionId,
+    task: summary.task,
+    stage: 'implement',
+    agent: 'executor',
+    mutation: summary.live ? 'isolated-workspace-diff' : 'mock-handoff-only',
+    target_project_mutated: false,
+    codex_review_run: false,
+    ship_run: false,
+    round: summary.round,
+    files: summary.files,
+    profile: summary.profile || null,
+    quality_checklist: summary.qualityChecklist || [],
+    diffPath: summary.diffPath,
+    acceptance_required: true,
+    acceptance_count: summary.acceptance?.criteria?.length || 0,
+    acceptance_source: summary.acceptance?.source || null,
+    acceptance_generated: Boolean(summary.acceptance?.generated),
+    next_step: 'run Codex verification before applying or shipping this work',
+  }, null, 2));
+}
+
+function writeHandoff(handoffDir, h) {
+  const base = handoffBase(h);
+  fs.writeFileSync(path.join(handoffDir, `${base}.json`), JSON.stringify(h, null, 2));
+  fs.writeFileSync(path.join(handoffDir, `${base}.md`), renderHandoff(h));
+}
+
+function handoffBase(h) {
+  const nn = STAGE_INDEX[h.stage] || '00';
+  const round = Number(h.round || 1);
+  const roundSuffix = round > 1 ? `-r${round}` : '';
+  return `${nn}-${h.stage}${roundSuffix}`;
+}
+
+function renderHandoff(h) {
+  const lines = [];
+  lines.push(`# Handoff: ${h.stage}  (round ${h.round || 1}, agent: ${h.agent}, ${h.provider}/${h.model})`);
+  lines.push('');
+  lines.push(`**Decided**: ${h.decided || ''}`);
+  if (h.rejected) lines.push(`**Rejected**: ${h.rejected}`);
+  if (h.risks) lines.push(`**Risks**: ${h.risks}`);
+  lines.push(`**Files**: ${(h.files || []).join(', ')}`);
+  if (h.remaining) lines.push(`**Remaining**: ${h.remaining}`);
+  if (h.diffPath) lines.push(`**Diff**: ${h.diffPath}`);
+  lines.push('');
+  lines.push('<sub>work mode: single executor; Codex review not run; ship not run</sub>');
+  return lines.join('\n') + '\n';
+}
+
+function dedupe(arr) {
+  return [...new Set(arr.filter(Boolean))];
+}
+
+export {
+  readPriorHandoffs as _readPriorHandoffs,
+  nextRound as _nextRound,
+};

package/scripts/portability/simulate-port.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+// PoC 이식 시뮬레이터. PORTING.md 의 30분 절차를 dry-run 으로 검증.
+//
+// 입력: --target <대상 디렉터리>  (사용자가 지정한 사내 프로젝트 경로)
+//       --profile <name>           (기본: research)
+//       또는 positional target: node scripts/portability/simulate-port.js <대상 디렉터리>
+//
+// 출력: 대상 디렉터리에 어떤 파일이 새로 들어갈지 / 어떤 파일이 보존되는지 / 충돌 가능성 리포트.
+// 실 변경 없음 (--apply 옵션 미존재).
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const HARNESS_ROOT = path.resolve(__dirname, '..', '..');
+
+function args() {
+  const a = { target: null, profile: 'research', verbose: false, json: false };
+  const argv = process.argv.slice(2);
+  for (let i = 0; i < argv.length; i++) {
+    const v = argv[i];
+    if (v === '--target') a.target = argv[++i];
+    else if (v === '--profile') a.profile = argv[++i];
+    else if (v === '--verbose') a.verbose = true;
+    else if (v === '--json') a.json = true;
+    else if (v === '--help' || v === '-h') { help(); process.exit(0); }
+    else if (!v.startsWith('-') && !a.target) a.target = v;
+    else { console.error(`알 수 없는: ${v}`); process.exit(2); }
+  }
+  return a;
+}
+
+function help() {
+  console.log(`
+HARNESS PoC 이식 시뮬레이터 (dry-run only).
+
+사용법:
+  node scripts/portability/simulate-port.js <dir> [--profile <name>] [--verbose] [--json]
+  node scripts/portability/simulate-port.js --target <dir> [--profile <name>] [--verbose] [--json]
+
+예:
+  node scripts/portability/simulate-port.js --target <대상 경로> --profile developer
+  node scripts/portability/simulate-port.js <대상 경로> --profile research --verbose
+`);
+}
+
+function inspectTarget(dir) {
+  const r = {
+    exists: false,
+    isGitRepo: false,
+    hasClaudeMd: false,
+    hasAgentsMd: false,
+    hasMcpJson: false,
+    hasHarnessTool: false,
+    hasHarnessState: false,
+    harnessDirs: [],
+    files: [],
+  };
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return r;
+  r.exists = true;
+  r.isGitRepo = fs.existsSync(path.join(dir, '.git'));
+  r.hasClaudeMd = fs.existsSync(path.join(dir, 'CLAUDE.md'));
+  r.hasAgentsMd = fs.existsSync(path.join(dir, 'AGENTS.md'));
+  r.hasMcpJson = fs.existsSync(path.join(dir, '.mcp.json'));
+  r.hasHarnessTool = fs.existsSync(path.join(dir, '.harness-tool'));
+  r.hasHarnessState = fs.existsSync(path.join(dir, '.harness'));
+  for (const p of ['.claude', '.codex', '.cursor', '.gemini', '.opencode']) {
+    if (fs.existsSync(path.join(dir, p))) r.harnessDirs.push(p);
+  }
+  for (const p of ['package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod', 'pom.xml', 'build.gradle', 'requirements.txt']) {
+    if (fs.existsSync(path.join(dir, p))) r.files.push(p);
+  }
+  return r;
+}
+
+function recommendStrategy(insp) {
+  // 가장 단순한 분류:
+  if (!insp.exists) return { strategy: 'create', reason: '대상 디렉터리 없음 — 새로 만들고 결합' };
+  if (insp.hasHarnessTool) return { strategy: 'update-existing-tool', reason: '이미 .harness-tool 이 있음 — 새 결합보다 업데이트/repair 우선' };
+  if (!insp.isGitRepo) return { strategy: 'init+submodule', reason: 'git 미초기화 — git init 후 submodule 권장' };
+  if (insp.hasClaudeMd || insp.hasAgentsMd) return { strategy: 'submodule', reason: 'CLAUDE/AGENTS.md 보존 + submodule 결합' };
+  return { strategy: 'submodule', reason: '표준 결합' };
+}
+
+function loadHarnessPlan(profile) {
+  const r = spawnSync(process.execPath, [
+    path.join(HARNESS_ROOT, 'scripts', 'install-plan.js'),
+    '--profile', profile, '--json',
+  ], { encoding: 'utf8' });
+  if (r.status !== 0) throw new Error(`harness plan 실패: ${r.stderr}`);
+  return JSON.parse(r.stdout);
+}
+
+function detectConflicts(target, plan, insp) {
+  const conflicts = [];
+  const conflictKeys = new Set();
+  const wouldAdd = [];
+  const wouldAddSet = new Set();
+  const markerManagedFiles = new Set(['CLAUDE.md', 'AGENTS.md']);
+
+  const addConflict = (severity, file, why) => {
+    const key = `${severity}\0${file}\0${why}`;
+    if (conflictKeys.has(key)) return;
+    conflictKeys.add(key);
+    conflicts.push({ severity, file, why });
+  };
+  const addWouldAdd = (targetPath) => {
+    if (wouldAddSet.has(targetPath)) return;
+    wouldAddSet.add(targetPath);
+    wouldAdd.push(targetPath);
+  };
+
+  if (path.resolve(target) === HARNESS_ROOT) {
+    addConflict('high', '.', '대상이 HARNESS 저장소 자체입니다. PoC 대상 프로젝트 루트를 별도로 지정하세요.');
+  }
+
+  if (insp.hasHarnessTool) {
+    addConflict('low', '.harness-tool', '이미 HARNESS tool 결합 흔적이 있습니다. 새 submodule 추가 대신 업데이트/repair 전략을 검토하세요.');
+  }
+
+  if (insp.hasHarnessState) {
+    addConflict('low', '.harness', '기존 HARNESS 상태 디렉터리가 있습니다. 세션/설치 상태를 보존하고 repair --check 로 정합성을 확인하세요.');
+  }
+
+  for (const dir of insp.harnessDirs) {
+    addConflict('medium', dir, '기존 하네스 출력 디렉터리가 있습니다. install-state 와 실제 산출물의 소유권을 확인하세요.');
+  }
+
+  // CLAUDE.md / AGENTS.md 마커 충돌 가능성
+  if (insp.hasClaudeMd) {
+    const text = fs.readFileSync(path.join(target, 'CLAUDE.md'), 'utf8');
+    if (!/<!--\s*HARNESS:START/i.test(text)) {
+      addConflict('medium', 'CLAUDE.md', '기존 CLAUDE.md 가 있고 HARNESS:START/END 마커가 없다 → 마커 영역 추가 필요');
+    }
+  }
+  if (insp.hasAgentsMd) {
+    const text = fs.readFileSync(path.join(target, 'AGENTS.md'), 'utf8');
+    if (!/<!--\s*HARNESS:START/i.test(text)) {
+      addConflict('medium', 'AGENTS.md', '기존 AGENTS.md 가 있고 HARNESS 마커가 없다 → 사용자 영역 보존 후 수동 머지 필요');
+    }
+  }
+  if (insp.hasMcpJson) {
+    addConflict('high', '.mcp.json', '기존 .mcp.json 존재 — harness 게이트웨이 추가 시 namespace 충돌 가능. 머지 필요.');
+  }
+  // 새 파일 vs 기존 파일
+  for (const c of plan.components || []) {
+    if (!c.target) continue;
+    if (c.type === 'platform' && insp.harnessDirs.includes(c.target)) continue;
+    const t = path.join(target, c.target);
+    if (fs.existsSync(t)) {
+      if (!markerManagedFiles.has(c.target)) {
+        addConflict('medium', c.target, `이미 존재 (${c.type}) — 덮어쓰기 위험. 백업 권장.`);
+      }
+    } else {
+      addWouldAdd(c.target);
+    }
+  }
+  return { conflicts, wouldAdd };
+}
+
+function printReport(report, json, verbose) {
+  if (json) { console.log(JSON.stringify(report, null, 2)); return; }
+  const C = (s) => process.stdout.isTTY ? `\x1b[1m${s}\x1b[0m` : s;
+  console.log('');
+  console.log(C(`HARNESS PoC 이식 시뮬레이터`));
+  console.log('  target            : ' + report.target);
+  console.log('  exists            : ' + report.inspection.exists);
+  console.log('  git repo          : ' + report.inspection.isGitRepo);
+  console.log('  CLAUDE.md         : ' + report.inspection.hasClaudeMd);
+  console.log('  AGENTS.md         : ' + report.inspection.hasAgentsMd);
+  console.log('  .mcp.json         : ' + report.inspection.hasMcpJson);
+  console.log('  .harness-tool     : ' + report.inspection.hasHarnessTool);
+  console.log('  harness dirs      : ' + report.inspection.harnessDirs.join(', '));
+  console.log('  package files     : ' + report.inspection.files.join(', '));
+  console.log('  추천 전략         : ' + report.strategy.strategy + ' (' + report.strategy.reason + ')');
+  console.log('  profile           : ' + report.profile);
+  console.log('  components plan   : ' + report.plan.component_count);
+  console.log('  새로 추가 (예상)  : ' + report.wouldAdd.length);
+  console.log('  충돌 (예상)       : ' + report.conflicts.length);
+  if (report.conflicts.length) {
+    console.log('');
+    console.log(C('충돌 / 주의:'));
+    for (const c of report.conflicts) console.log(`  - [${c.severity}] ${c.file} — ${c.why}`);
+  }
+  if (verbose) {
+    console.log('');
+    console.log(C('새로 추가될 파일/디렉터리 (일부):'));
+    for (const f of report.wouldAdd.slice(0, 20)) console.log('  + ' + f);
+    if (report.wouldAdd.length > 20) console.log(`  ... (+${report.wouldAdd.length - 20}개)`);
+  }
+  console.log('');
+  console.log('NOTE: 이 시뮬레이터는 변경하지 않는다. 실제 결합은 PORTING.md 의 절차를 따른다.');
+  console.log('');
+}
+
+function main() {
+  const a = args();
+  if (!a.target) { console.error('--target 필요'); help(); process.exit(2); }
+  const target = path.resolve(a.target);
+  const insp = inspectTarget(target);
+  const strategy = recommendStrategy(insp);
+  const plan = loadHarnessPlan(a.profile);
+  const { conflicts, wouldAdd } = detectConflicts(target, plan, insp);
+  const report = {
+    target, profile: a.profile,
+    harness_version: plan.harness_version,
+    inspection: insp,
+    strategy,
+    plan: { component_count: plan.component_count, modules: plan.modules },
+    wouldAdd, conflicts,
+    note: 'dry-run only',
+  };
+  printReport(report, a.json, a.verbose);
+  if (conflicts.some(c => c.severity === 'high')) process.exit(1);
+}
+
+main();

package/scripts/repair.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+// HARNESS repair : install-state.json 과 실 디스크의 빌드 산출물을 비교해
+// 누락 / sha256 불일치인 하네스만 다시 빌드한다. install-apply 의 경량판.
+//
+// - state 파일 없음 → 안내 후 종료.
+// - 빌드 산출 디렉터리 누락 → 해당 빌더 재실행.
+// - 디렉터리 존재하지만 산출 sha256 (전 디렉터리 합산) 가 다름 → 재빌드.
+// - --check 면 변경 없음. 부정합만 보고하고 exit 1.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import YAML from 'yaml';
+import {
+  ZERO_SHA,
+  assertInstallState,
+  buildInstallState,
+  installStatePath,
+  loadInstallState,
+  sha256OfCatalog,
+  sha256OfDir,
+  writeInstallState,
+} from './core/install-state.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = path.resolve(__dirname, '..');
+const STATE_FILE = installStatePath(ROOT);
+
+function parseArgs(argv) {
+  const args = { check: false, harness: null, force: false, verbose: false };
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--check') args.check = true;
+    else if (a === '--harness') args.harness = argv[++i];
+    else if (a === '--force') args.force = true;
+    else if (a === '--verbose' || a === '-v') args.verbose = true;
+    else if (a === '--help' || a === '-h') { printHelp(); process.exit(0); }
+    else { console.error(`알 수 없는 인자: ${a}`); process.exit(2); }
+  }
+  return args;
+}
+
+function printHelp() {
+  console.log(`
+HARNESS repair
+
+사용법:
+  node scripts/repair.js [--check] [--harness <name>] [--force] [--verbose]
+
+옵션:
+  --check          변경 없이 부정합만 보고. 부정합 있으면 exit 1.
+  --harness <n>    특정 하네스만 검사 (claude | codex | cursor | gemini | opencode)
+  --force          모든 하네스 강제 재빌드 (state 무시).
+  --verbose        상세 로그.
+`);
+}
+
+function runBuilder(name) {
+  const script = path.join(__dirname, `build-${name}.js`);
+  if (!fs.existsSync(script)) {
+    console.error(`  [SKIP] build-${name}.js 없음`);
+    return false;
+  }
+  const r = spawnSync(process.execPath, [script], { stdio: 'inherit' });
+  return r.status === 0;
+}
+
+function main() {
+  const args = parseArgs(process.argv);
+
+  const manifest = YAML.parse(fs.readFileSync(path.join(ROOT, 'agent.yaml'), 'utf8'));
+  const harnessDefs = manifest.harnesses || [];
+  const sourceSha = sha256OfCatalog(ROOT);
+
+  let state = loadInstallState(ROOT);
+  if (state) {
+    try {
+      assertInstallState(ROOT, state);
+    } catch (e) {
+      console.error(e.message);
+      process.exit(1);
+    }
+  } else if (!args.force) {
+    console.error('install-state.json 없음. 먼저 `install.sh --apply` 실행 필요.');
+    console.error(`(${path.relative(ROOT, STATE_FILE)})`);
+    process.exit(1);
+  }
+
+  const targets = harnessDefs.filter(h => !args.harness || h.name === args.harness);
+  if (args.harness && targets.length === 0) {
+    console.error(`알 수 없는 하네스: ${args.harness}`);
+    process.exit(2);
+  }
+
+  const issues = []; // { harness, reason }
+  for (const h of targets) {
+    const outDir = path.join(ROOT, h.output_dir);
+    const exists = fs.existsSync(outDir);
+    const stateEntry = state?.components?.[h.name];
+
+    if (args.force) {
+      issues.push({ harness: h.name, reason: 'force 옵션' });
+      continue;
+    }
+
+    if (!exists) {
+      issues.push({ harness: h.name, reason: `${h.output_dir} 없음` });
+      continue;
+    }
+
+    if (!stateEntry) {
+      issues.push({ harness: h.name, reason: 'state 미기록 (install-apply 미실행 또는 외부 추가)' });
+      continue;
+    }
+
+    if (stateEntry.source_sha256 === ZERO_SHA || stateEntry.source_sha256 !== sourceSha) {
+      issues.push({
+        harness: h.name,
+        reason: `source_sha256 불일치 (${sourceSha.slice(0, 12)} vs ${(stateEntry.source_sha256 || '').slice(0, 12)})`,
+      });
+      continue;
+    }
+
+    // 이전 state 의 target placeholder("0"*64) 는 비교 무의미 → 재빌드 후 실값으로 회수한다.
+    const stateSha = stateEntry.targets?.[0]?.sha256 || null;
+    if (stateSha === ZERO_SHA) {
+      issues.push({ harness: h.name, reason: 'target sha256 placeholder' });
+      continue;
+    }
+    if (stateSha) {
+      const actualSha = sha256OfDir(outDir);
+      if (actualSha !== stateSha) {
+        issues.push({ harness: h.name, reason: `sha256 불일치 (${actualSha?.slice(0, 12)} vs ${stateSha.slice(0, 12)})` });
+        continue;
+      }
+    }
+
+    if (args.verbose) console.log(`[OK]   ${h.name}: ${h.output_dir}`);
+  }
+
+  if (issues.length === 0) {
+    console.log('모든 하네스 정합. 재빌드 불필요.');
+    return;
+  }
+
+  console.log(`재빌드 필요 (${issues.length}):`);
+  for (const i of issues) console.log(`  - ${i.harness.padEnd(10)} ${i.reason}`);
+  console.log('');
+
+  if (args.check) {
+    console.error('--check 모드. 재빌드 안 함.');
+    process.exit(1);
+  }
+
+  let failed = 0;
+  for (const i of issues) {
+    console.log(`=> rebuild ${i.harness}`);
+    if (!runBuilder(i.harness)) {
+      console.error(`  build-${i.harness} 실패`);
+      failed++;
+    }
+  }
+
+  if (failed > 0) {
+    console.error(`\n${failed}개 빌더 실패.`);
+    process.exit(1);
+  }
+
+  const rebuilt = issues.map(i => i.harness);
+  const updated = buildInstallState(ROOT, {
+    profile: state?.profile || manifest.profiles?.default || 'developer',
+    harnessDefs,
+    harnessNames: rebuilt,
+    previousState: state,
+  }).state;
+  state = updated;
+  writeInstallState(ROOT, state);
+  console.log(`\nstate 갱신: ${path.relative(ROOT, STATE_FILE)}`);
+
+  console.log('repair 완료.');
+}
+
+main();