vibe-commander 0.2.4 → 0.2.6

package/dist/adapters/cli/commands/init-helpers.d.ts

@@ -10,7 +10,7 @@
  * @module
  */
 import type { ToolResult, ScanResult, InitAnswers, InitResult } from '../../../types/index.js';
-export { DEFAULT_COMMANDS_PATH, DEFAULT_ROADMAP_PATH, DEFAULT_PLAN_DIR, DEFAULT_RESULT_DIR, DEFAULT_ID_PATTERN, DEFAULT_COMMAND_SECTION, DEFAULT_HEADER_TEMPLATE, extractStdinAnswers, buildAnswersFromScan, } from '../../../core/resolvers/config-generator.js';
+export { DEFAULT_COMMANDS_PATH, DEFAULT_ROADMAP_PATH, DEFAULT_PLAN_DIR, DEFAULT_RESULT_DIR, DEFAULT_RUNBOOK_DIR, DEFAULT_ID_PATTERN, DEFAULT_COMMAND_SECTION, DEFAULT_HEADER_TEMPLATE, extractStdinAnswers, buildAnswersFromScan, } from '../../../core/resolvers/config-generator.js';
 /**
  * 수집된 정보로 설정 객체를 구성하고, 검증 후 파일에 쓴다
  *

package/dist/adapters/cli/commands/init-helpers.js

@@ -15,14 +15,14 @@ import { projectConfigSchema } from '../../../config/schema.js';
 import { CYAN, YELLOW, GREEN, DIM, RESET, BOLD } from '../output.js';
 import { mergeConfigs } from '../../../core/resolvers/config-merger.js';
 import { buildConfigObject } from '../../../core/resolvers/config-generator.js';
-export { DEFAULT_COMMANDS_PATH, DEFAULT_ROADMAP_PATH, DEFAULT_PLAN_DIR, DEFAULT_RESULT_DIR, DEFAULT_ID_PATTERN, DEFAULT_COMMAND_SECTION, DEFAULT_HEADER_TEMPLATE, extractStdinAnswers, buildAnswersFromScan, } from '../../../core/resolvers/config-generator.js';
+export { DEFAULT_COMMANDS_PATH, DEFAULT_ROADMAP_PATH, DEFAULT_PLAN_DIR, DEFAULT_RESULT_DIR, DEFAULT_RUNBOOK_DIR, DEFAULT_ID_PATTERN, DEFAULT_COMMAND_SECTION, DEFAULT_HEADER_TEMPLATE, extractStdinAnswers, buildAnswersFromScan, } from '../../../core/resolvers/config-generator.js';
 /**
  * 수집된 정보로 설정 객체를 구성하고, 검증 후 파일에 쓴다
  *
  * @param mergeWith - 기존 설정 객체. 제공되면 스캔 결과와 병합한다.
  */
 export function buildAndWriteConfig(answers, configPath, alreadyExists, scanResult, mergeWith) {
-    let configObj = buildConfigObject(answers);
+    let configObj = buildConfigObject(answers, scanResult);
     if (mergeWith) {
         configObj = mergeConfigs(mergeWith, configObj);
     }

package/dist/adapters/cli/commands/init-interactive.js

@@ -17,7 +17,7 @@ import { fail } from '../../../types/index.js';
 import { CONFIG_FILENAME } from '../../../config/schema.js';
 import { isValidRegex } from '../../../core/resolvers/config-validator.js';
 import { CYAN, YELLOW, DIM, RESET, BOLD } from '../output.js';
-import { DEFAULT_COMMANDS_PATH, DEFAULT_ROADMAP_PATH, DEFAULT_PLAN_DIR, DEFAULT_RESULT_DIR, DEFAULT_ID_PATTERN, DEFAULT_COMMAND_SECTION, buildAnswersFromScan, buildAndWriteConfig, printScanResults, } from './init-helpers.js';
+import { DEFAULT_COMMANDS_PATH, DEFAULT_ROADMAP_PATH, DEFAULT_PLAN_DIR, DEFAULT_RESULT_DIR, DEFAULT_RUNBOOK_DIR, DEFAULT_ID_PATTERN, DEFAULT_COMMAND_SECTION, buildAnswersFromScan, buildAndWriteConfig, printScanResults, } from './init-helpers.js';
 /**
  * 대화형 모드 — readline으로 질문을 수집하고 설정 파일을 생성한다
  */
@@ -105,7 +105,7 @@ async function collectAnswers(rl) {
     const roadmapPath = await askNullable(rl, '로드맵 파일 경로 (없으면 Enter)', DEFAULT_ROADMAP_PATH);
     const planDir = await askWithDefault(rl, '계획서 디렉토리', DEFAULT_PLAN_DIR);
     const resultDir = await askWithDefault(rl, '결과 보고서 디렉토리', DEFAULT_RESULT_DIR);
-    const runbookDir = await askNullable(rl, '런북 디렉토리 (없으면 Enter)', '');
+    const runbookDir = await askNullable(rl, '런북 디렉토리 (없으면 Enter)', DEFAULT_RUNBOOK_DIR);
     const idPattern = await askWithDefault(rl, '유닛 ID 패턴 (정규식)', DEFAULT_ID_PATTERN);
     const validPattern = isValidRegex(idPattern);
     if (!validPattern) {
@@ -132,7 +132,7 @@ async function askWithDefault(rl, prompt, defaultValue) {
 /**
  * null 가능한 질문 프롬프트 (빈 입력 → null)
  */
-async function askNullable(rl, prompt, defaultValue) {
+async function askNullable(rl, prompt, defaultValue = '') {
     const display = defaultValue ? ` ${DIM}[${defaultValue}]${RESET}` : '';
     const answer = await rl.question(`${CYAN}? ${prompt}${RESET}${display}: `);
     const trimmed = answer.trim();

package/dist/adapters/cli/commands/set-unit.d.ts

@@ -24,6 +24,8 @@ export interface SetUnitResult {
     pairingQuestions: PairingQuestion[];
     pairingAnswers: PairingAnswer[];
     commandsUpdated: boolean;
+    planUpdated?: boolean;
+    questionsWrittenBack?: number;
     warnings: string[];
     dryRun?: boolean;
     preview?: string;

package/dist/adapters/cli/commands/set-unit.js

@@ -18,6 +18,7 @@ import { parseBacklog } from '../../../core/parsers/backlog-parser.js';
 import { classifyBacklog } from '../../../core/resolvers/backlog-resolver.js';
 import { renderSection } from '../../../core/renderers/section-renderer.js';
 import { updateSection } from '../../../core/renderers/section-updater.js';
+import { updatePlanQuestions } from '../../../core/renderers/plan-question-updater.js';
 import { findMarkerRange } from '../../../core/renderers/marker-utils.js';
 import { extractSubsectionContent } from '../../../core/parsers/subsection-extractor.js';
 import { normalizeLineEndings } from '../../../core/parsers/md-utils.js';
@@ -76,9 +77,30 @@ export async function handleSetUnit(args, projectRoot) {
         pairingAnswers = await promptAllQuestions(context.pairingQuestions);
         context.pairingAnswers = pairingAnswers;
     }
-    // 3. 커맨드 파일 읽기 (보존 추출 + 업데이트에 재사용)
+    // 3. 계획서 Writeback (답변이 있고 dry-run이 아닐 때만)
+    let planUpdated = false;
+    let questionsWrittenBack = 0;
+    if (!dryRun && pairingAnswers.length > 0) {
+        try {
+            const planAbsPath = join(projectRoot, planRelPath);
+            const planContent = readFileSync(planAbsPath, 'utf-8');
+            const writebackResult = updatePlanQuestions(planContent, pairingAnswers, {
+                pairingQuestionSection: config.planParsing.pairingQuestionSection,
+            });
+            if (writebackResult.appliedCount > 0) {
+                writeFileSync(planAbsPath, writebackResult.updatedContent, 'utf-8');
+                planUpdated = true;
+                questionsWrittenBack = writebackResult.appliedCount;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            warnings.push(`계획서 Writeback 실패: ${msg}`);
+        }
+    }
+    // 4. 커맨드 파일 읽기 (보존 추출 + 업데이트에 재사용)
     const cmdFile = readCommandsFile(config, projectRoot);
-    // 4. 기존 특별 요청사항 추출 (보존 로직)
+    // 5. 기존 특별 요청사항 추출 (보존 로직)
     const specialRequestsHeading = config.commandSections.specialRequestsHeading;
     let preservedSpecialRequests;
     if (cmdFile.success) {
@@ -87,12 +109,12 @@ export async function handleSetUnit(args, projectRoot) {
             preservedSpecialRequests = extracted;
         }
     }
-    // 5. 섹션 렌더링 (Core 순수 함수)
+    // 6. 섹션 렌더링 (Core 순수 함수)
     const sectionBody = renderSection(context, unitTypeConfig, undefined, {
         preservedSpecialRequests,
         specialRequestsHeading,
     });
-    // 6. 커맨드 파일 업데이트 (Adapter I/O) — dry-run 시 건너뜀
+    // 7. 커맨드 파일 업데이트 (Adapter I/O) — dry-run 시 건너뜀
     let commandsUpdated = false;
     if (!dryRun) {
         if (cmdFile.success) {
@@ -116,10 +138,10 @@ export async function handleSetUnit(args, projectRoot) {
         else {
             warnings.push(`커맨드 파일을 읽을 수 없습니다: ${config.paths.commands}`);
         }
-        // 7. 활성 유닛 타입 상태 기록 (update-commit 자동 감지용)
+        // 8. 활성 유닛 타입 상태 기록 (update-commit 자동 감지용)
         writeActiveUnitType(projectRoot, unitTypeKey);
     }
-    // 6. 결과 반환
+    // 9. 결과 반환
     return ok({
         unitId,
         unitType: unitTypeKey,
@@ -131,6 +153,7 @@ export async function handleSetUnit(args, projectRoot) {
         pairingQuestions: context.pairingQuestions,
         pairingAnswers,
         commandsUpdated,
+        ...(planUpdated && { planUpdated, questionsWrittenBack }),
         warnings,
         ...(dryRun && { dryRun: true, preview: sectionBody }),
         ...(autoSelected && { autoSelected, selectedFrom }),

package/dist/adapters/cli/scanner.js

@@ -80,19 +80,25 @@ function detectIdPatterns(mdFiles) {
         // [우선순위 1] PREFIX-NNN[Tag] (예: U-001[Mvp], RU-001[Mmp])
         const tagMatch = name.match(/^([A-Z][A-Z0-9]*)-\d+\[/);
         if (tagMatch?.[1]) {
-            upsertGroup(prefixGroups, tagMatch[1], name, true, false);
+            upsertGroup(prefixGroups, tagMatch[1], name, true, false, false);
+            continue;
+        }
+        // [우선순위 1.5] PREFIX-NNN-XN (예: RU-010-S1, RU-013-Q2)
+        const subUnitMatch = name.match(/^([A-Z][A-Z0-9]*)-\d+-[A-Z]\d+$/);
+        if (subUnitMatch?.[1]) {
+            upsertGroup(prefixGroups, subUnitMatch[1], name, false, false, true);
             continue;
         }
         // [우선순위 2] PREFIX-WORD-NNN (예: CP-MVP-01)
         const compoundMatch = name.match(/^([A-Z][A-Z0-9]*)-[A-Z][A-Z0-9]*-\d+/);
         if (compoundMatch?.[1]) {
-            upsertGroup(prefixGroups, compoundMatch[1], name, false, true);
+            upsertGroup(prefixGroups, compoundMatch[1], name, false, true, false);
             continue;
         }
         // [우선순위 3] PREFIX-NNN (예: TASK-001)
         const basicMatch = name.match(/^([A-Z][A-Z0-9]*)-\d+/);
         if (basicMatch?.[1]) {
-            upsertGroup(prefixGroups, basicMatch[1], name, false, false);
+            upsertGroup(prefixGroups, basicMatch[1], name, false, false, false);
         }
     }
     const patterns = [];
@@ -113,12 +119,14 @@ function detectIdPatterns(mdFiles) {
             displayLabel,
             matchCount: group.names.length,
             examples: group.names.slice(0, 3),
+            hasTag: group.hasTag,
+            hasSubUnit: group.hasSubUnit,
         });
     }
     patterns.sort((a, b) => b.matchCount - a.matchCount);
     return patterns;
 }
-function upsertGroup(groups, prefix, name, hasTag, isCompound) {
+function upsertGroup(groups, prefix, name, hasTag, isCompound, hasSubUnit) {
     const existing = groups.get(prefix);
     if (existing) {
         existing.names.push(name);
@@ -126,9 +134,11 @@ function upsertGroup(groups, prefix, name, hasTag, isCompound) {
             existing.hasTag = true;
         if (isCompound)
             existing.isCompound = true;
+        if (hasSubUnit)
+            existing.hasSubUnit = true;
     }
     else {
-        groups.set(prefix, { names: [name], hasTag, isCompound });
+        groups.set(prefix, { names: [name], hasTag, isCompound, hasSubUnit });
     }
 }
 // ── 문서 디렉토리 감지 ──
@@ -136,6 +146,7 @@ const ROLE_KEYWORDS = {
     plan: ['plan', 'plans', 'unit-plan', 'unit-plans'],
     result: ['result', 'results', 'unit-result', 'unit-results', 'report', 'reports'],
     runbook: ['runbook', 'runbooks', 'unit-runbook', 'unit-runbooks'],
+    refactorSub: ['refactor', 'refactors', 'refactoring'],
 };
 function detectDocRoots(mdFiles) {
     const dirCounts = new Map();
@@ -159,7 +170,13 @@ function detectDocRoots(mdFiles) {
             docRoots.push({ role, dirPath: dir, fileCount: count });
         }
     }
-    const roleOrder = { plan: 0, result: 1, runbook: 2, other: 3 };
+    const roleOrder = {
+        plan: 0,
+        result: 1,
+        runbook: 2,
+        refactorSub: 3,
+        other: 4,
+    };
     docRoots.sort((a, b) => {
         const orderDiff = (roleOrder[a.role] ?? 3) - (roleOrder[b.role] ?? 3);
         if (orderDiff !== 0)

package/dist/core/parsers/dep-line-parser.js

@@ -43,12 +43,19 @@ export function parseDependencyLines(lines, idPattern) {
                     artifacts: currentArtifacts,
                 });
             }
-            // 새 dep 파싱
-            const parsed = extractDepFromLine(trimmed, idPattern);
-            if (parsed) {
-                currentUnitId = parsed.unitId;
-                currentDescription = parsed.description;
-                currentArtifacts = parsed.artifacts;
+            // 새 dep 파싱 (멀티 반환 지원)
+            const parsedList = extractDepFromLine(trimmed, idPattern);
+            if (parsedList.length > 0) {
+                // 마지막 이외 항목은 즉시 deps에 push (하위 항목은 마지막 유닛에만 연결)
+                for (let i = 0; i < parsedList.length - 1; i++) {
+                    const dep = parsedList[i];
+                    if (dep)
+                        deps.push(dep);
+                }
+                const last = parsedList[parsedList.length - 1];
+                currentUnitId = last?.unitId ?? '';
+                currentDescription = last?.description ?? '';
+                currentArtifacts = last?.artifacts;
                 hasCurrent = true;
             }
             else {
@@ -83,49 +90,132 @@ export function parseDependencyLines(lines, idPattern) {
     return { deps, contextNotes };
 }
 /**
- * 한 라인에서 의존 유닛 정보를 추출한다
+ * 한 라인에서 의존 유닛 정보를 추출한다 (멀티 반환 지원)
  *
  * 추출 우선순위:
  * 1. 링크 텍스트 `[ID](url)` — 더 구체적 (문서 링크 포함)
  * 2. 볼드 텍스트 `**ID**` — 일반적인 의존성 표기
  *
  * idPattern이 제공되면 추출된 후보를 필터링하여 실제 유닛 ID만 선별.
+ * 한 줄에 콤마로 구분된 복수 유닛이 있을 경우 모두 추출.
  *
  * @param line - 리스트 항목 라인 (리스트 마커 제거 전)
  * @param idPattern - 유닛 ID 필터링 패턴 (선택)
- * @returns 추출된 DepInfo 또는 null
+ * @returns 추출된 DepInfo 배열 (없으면 빈 배열)
  */
 function extractDepFromLine(line, idPattern) {
-    // 리스트 마커 제거
     const content = line.replace(/^[-*]\s+/, '');
-    // 후보 ID 수집 (링크 우선, 볼드 후순위)
     const candidates = [];
-    // 링크 텍스트: [ID](url) — 중첩 괄호 1레벨 지원 (예: [U-002[Mvp]])
     const linkRegex = /\[((?:[^[\]]*(?:\[[^\]]*\])?[^[\]]*)*)\]\([^)]*\)/g;
     let match;
     while ((match = linkRegex.exec(content)) !== null) {
         if (match[1])
-            candidates.push({ id: match[1].trim(), source: 'link' });
+            candidates.push({
+                id: match[1].trim(),
+                source: 'link',
+                matchStart: match.index,
+                matchEnd: match.index + match[0].length,
+            });
     }
-    // 볼드 텍스트: **ID**
     const boldRegex = /\*\*([^*]+)\*\*/g;
     while ((match = boldRegex.exec(content)) !== null) {
         if (match[1])
-            candidates.push({ id: match[1].trim(), source: 'bold' });
+            candidates.push({
+                id: match[1].trim(),
+                source: 'bold',
+                matchStart: match.index,
+                matchEnd: match.index + match[0].length,
+            });
+    }
+    // 3. 평문 ID Fallback: 볼드/링크가 없고 idPattern이 제공된 경우에만 시도
+    if (candidates.length === 0 && idPattern) {
+        const plainIdRegex = safeRegex(idPattern);
+        if (plainIdRegex) {
+            // 앵커 제거한 버전으로 전체 스캔 (멀티 ID 지원용)
+            const scanPattern = plainIdRegex.source.replace(/^\^/, '');
+            const globalIdRegex = new RegExp(scanPattern, 'g');
+            let plainMatch;
+            while ((plainMatch = globalIdRegex.exec(content)) !== null) {
+                // 단, 평문 ID는 반드시 토큰 시작점(공백/마커 직후)이거나 콤마 뒤여야 함
+                const charBefore = content[plainMatch.index - 1];
+                const isStartOfToken = !charBefore || /[\s,:]/.test(charBefore);
+                if (isStartOfToken) {
+                    candidates.push({
+                        id: plainMatch[0],
+                        source: 'plain',
+                        matchStart: plainMatch.index,
+                        matchEnd: plainMatch.index + plainMatch[0].length,
+                    });
+                }
+            }
+        }
     }
     if (candidates.length === 0)
-        return null;
-    // idPattern으로 필터링: 볼드 헤더(`**헤더**: [ID](url)`)에서 비유닛 볼드를 건너뜀
+        return [];
     const idRegex = idPattern ? safeRegex(idPattern) : null;
-    const validCandidate = idRegex ? candidates.find((c) => idRegex.test(c.id)) : candidates[0];
-    if (!validCandidate)
-        return null;
-    const unitId = validCandidate.id;
-    if (isNoneDependency(unitId))
-        return null;
-    // 설명 추출: ID 참조 이후의 텍스트에서 구분자 제거
-    const description = extractDescription(content, unitId, validCandidate.source);
-    return { unitId, description };
+    const validCandidates = idRegex
+        ? candidates
+            .filter((c) => idRegex.test(c.id))
+            .map((c) => {
+            // ID 패턴으로 실제 유닛 ID 부분만 추출 (정규화)
+            // 예: **[U-101](url)** -> U-101, U-101[Mmp]:설명 -> U-101[Mmp]
+            const actualMatch = c.id.match(idRegex);
+            if (actualMatch) {
+                const normalizedId = actualMatch[0];
+                if (c.source === 'plain') {
+                    const offset = c.id.indexOf(normalizedId);
+                    const newStart = c.matchStart + (offset !== -1 ? offset : 0);
+                    return {
+                        ...c,
+                        id: normalizedId,
+                        matchStart: newStart,
+                        matchEnd: newStart + normalizedId.length,
+                    };
+                }
+                else {
+                    // 볼드/링크: ID만 정규화하고 매칭 범위(마커 포함)는 유지하여 설명 추출 보호
+                    return { ...c, id: normalizedId };
+                }
+            }
+            return c;
+        })
+        : candidates[0]
+            ? [candidates[0]]
+            : [];
+    // None 의존성 필터링 + 동일 ID 중복 제거 (첫 등장 유지)
+    const seen = new Set();
+    const filtered = validCandidates.filter((c) => {
+        if (isNoneDependency(c.id))
+            return false;
+        if (seen.has(c.id))
+            return false;
+        seen.add(c.id);
+        return true;
+    });
+    if (filtered.length === 0)
+        return [];
+    // 단일 후보: 기존 extractDescription 로직 사용 (성능/호환성 보장)
+    if (filtered.length === 1) {
+        const c = filtered[0];
+        if (!c)
+            return [];
+        if (c.source === 'plain') {
+            const descText = content.slice(c.matchEnd);
+            const description = cleanupMultiDescription(descText);
+            return [{ unitId: c.id, description }];
+        }
+        const description = extractDescription(content, c.id, c.source);
+        return [{ unitId: c.id, description }];
+    }
+    // 복수 후보: 등장 순서 정렬 후 위치 기반 description 범위 분할
+    const sorted = [...filtered].sort((a, b) => a.matchStart - b.matchStart);
+    return sorted.map((c, i) => {
+        const nextCandidate = sorted[i + 1];
+        const nextStart = nextCandidate ? nextCandidate.matchStart : content.length;
+        const descText = content.slice(c.matchEnd, nextStart);
+        const description = cleanupMultiDescription(descText);
+        return { unitId: c.id, description };
+    });
 }
 /**
  * ID 참조 이후의 설명 텍스트를 추출한다
@@ -157,6 +247,19 @@ function extractDescription(content, unitId, source) {
     rest = rest.replace(/^[—-]\s+/, '');
     return rest.trim();
 }
+/**
+ * 멀티 의존성 description 텍스트를 정리한다
+ *
+ * 위치 기반 범위 분할로 추출된 raw description에서
+ * 선행 구분자(`:`, `—`, `-`)와 후행 콤마를 제거.
+ */
+function cleanupMultiDescription(text) {
+    let rest = text.trim();
+    rest = rest.replace(/^[:—]\s*/, '');
+    rest = rest.replace(/^[—-]\s+/, '');
+    rest = rest.replace(/,\s*$/, '');
+    return rest.trim();
+}
 /**
  * 하위 항목에서 artifact 텍스트를 추출한다
  *

package/dist/core/renderers/index.d.ts

@@ -13,6 +13,8 @@ export { updateSection, updateField } from './section-updater.js';
 export type { UpdateResult, MarkerOptions } from './section-updater.js';
 export { createBeginMarker, createEndMarker, findMarkerRange, isValidSectionKey, wrapWithMarkers, stripMarkers, } from './marker-utils.js';
 export type { MarkerRange } from './marker-utils.js';
+export { updatePlanQuestions } from './plan-question-updater.js';
+export type { PlanQuestionUpdateResult } from './plan-question-updater.js';
 export { COMMAND_REGISTRY, SCHEMA_SUBCOMMANDS, renderConfigSchema, renderCommandsSchema, renderTypesSchema, } from './schema-renderer.js';
 export type { ArgSchema, FlagSchema, CommandSchema, TypeSchemaEntry, SchemaSubcommandInfo, SchemaResult, } from './schema-renderer.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/renderers/index.js

@@ -15,6 +15,8 @@ export { renderSection } from './section-renderer.js';
 export { updateSection, updateField } from './section-updater.js';
 // 마커 유틸리티
 export { createBeginMarker, createEndMarker, findMarkerRange, isValidSectionKey, wrapWithMarkers, stripMarkers, } from './marker-utils.js';
+// 계획서 질문 Writeback
+export { updatePlanQuestions } from './plan-question-updater.js';
 // 스키마 렌더러
 export { COMMAND_REGISTRY, SCHEMA_SUBCOMMANDS, renderConfigSchema, renderCommandsSchema, renderTypesSchema, } from './schema-renderer.js';
 //# sourceMappingURL=index.js.map

package/dist/core/renderers/plan-question-updater.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 계획서 페어링 질문 Writeback — Layer 1 순수 함수
+ *
+ * 페어링 질문에 대한 CLI 답변을 계획서 원본 마크다운에 반영한다.
+ * `[ ]` → `[x]` 체크, 답변 텍스트 추가, 선택된 옵션 `✅` 마킹.
+ *
+ * pairing-question-extractor.ts의 QUESTION_LINE 정규식과 동일한
+ * 패턴을 사용하여 파싱/업데이트 간 일관성을 보장한다.
+ *
+ * @module
+ */
+import type { PairingAnswer } from '../../types/index.js';
+/** updatePlanQuestions 반환 타입 */
+export interface PlanQuestionUpdateResult {
+    /** 업데이트된 계획서 전체 content */
+    updatedContent: string;
+    /** 실제 반영된 답변 수 */
+    appliedCount: number;
+}
+/**
+ * 계획서 content에서 페어링 질문 체크박스를 답변에 따라 업데이트한다
+ *
+ * 동작:
+ * 1. planContent에서 `## {pairingQuestionSection}` 섹션 시작/끝 라인 범위를 찾음
+ * 2. 섹션 내 각 질문 라인(`- [ ] **{id}**:`)을 순회
+ * 3. answers 배열에 해당 questionId가 있으면:
+ *    - `[ ]` → `[x]`로 교체
+ *    - 질문 라인 끝에 ` → **답변: {selectedOption 또는 freeText}**` 추가
+ * 4. 옵션 라인 중 선택된 옵션이 있으면 해당 라인에 `✅` 추가
+ * 5. answers에 없는 질문(건너뜀)은 원본 유지
+ * 6. 섹션 외 content는 그대로 보존
+ *
+ * @param planContent - 계획서 마크다운 전체 내용
+ * @param answers - CLI 프롬프트에서 수집된 답변 배열
+ * @param config - 페어링 질문 섹션명 설정
+ * @returns 업데이트된 content와 반영된 답변 수
+ */
+export declare function updatePlanQuestions(planContent: string, answers: PairingAnswer[], config: {
+    pairingQuestionSection: string;
+}): PlanQuestionUpdateResult;
+//# sourceMappingURL=plan-question-updater.d.ts.map

package/dist/core/renderers/plan-question-updater.js

@@ -0,0 +1,150 @@
+/**
+ * 계획서 페어링 질문 Writeback — Layer 1 순수 함수
+ *
+ * 페어링 질문에 대한 CLI 답변을 계획서 원본 마크다운에 반영한다.
+ * `[ ]` → `[x]` 체크, 답변 텍스트 추가, 선택된 옵션 `✅` 마킹.
+ *
+ * pairing-question-extractor.ts의 QUESTION_LINE 정규식과 동일한
+ * 패턴을 사용하여 파싱/업데이트 간 일관성을 보장한다.
+ *
+ * @module
+ */
+import { findSectionLines, normalizeLineEndings } from '../parsers/md-utils.js';
+/**
+ * 질문 라인 정규식 (pairing-question-extractor.ts와 동일 패턴)
+ *
+ * - checked: 체크 상태 ('x', 'X', 'v', 'V', 공백 등)
+ * - id: 질문 ID (예: "Q1")
+ * - text: 질문 본문
+ */
+const QUESTION_LINE = /^(?<prefix>[-*]\s+)\[(?<checked>[xXvV ]*)\]\s+\*\*(?<id>[^*]+)\*\*\s*(?<sep>[:\-—]?)\s*(?<text>.+)$/;
+/**
+ * 하위 옵션 라인 정규식 (들여쓰인 리스트 항목)
+ */
+const SUB_OPTION_LINE = /^(?<indent>\s{2,})(?<bullet>[-*]\s+)(?<optionText>.+)$/;
+/**
+ * 이미 체크된 상태인지 판별
+ */
+function isChecked(mark) {
+    const lower = mark.toLowerCase();
+    return lower.includes('x') || lower.includes('v');
+}
+/**
+ * 계획서 content에서 페어링 질문 체크박스를 답변에 따라 업데이트한다
+ *
+ * 동작:
+ * 1. planContent에서 `## {pairingQuestionSection}` 섹션 시작/끝 라인 범위를 찾음
+ * 2. 섹션 내 각 질문 라인(`- [ ] **{id}**:`)을 순회
+ * 3. answers 배열에 해당 questionId가 있으면:
+ *    - `[ ]` → `[x]`로 교체
+ *    - 질문 라인 끝에 ` → **답변: {selectedOption 또는 freeText}**` 추가
+ * 4. 옵션 라인 중 선택된 옵션이 있으면 해당 라인에 `✅` 추가
+ * 5. answers에 없는 질문(건너뜀)은 원본 유지
+ * 6. 섹션 외 content는 그대로 보존
+ *
+ * @param planContent - 계획서 마크다운 전체 내용
+ * @param answers - CLI 프롬프트에서 수집된 답변 배열
+ * @param config - 페어링 질문 섹션명 설정
+ * @returns 업데이트된 content와 반영된 답변 수
+ */
+export function updatePlanQuestions(planContent, answers, config) {
+    if (answers.length === 0) {
+        return { updatedContent: planContent, appliedCount: 0 };
+    }
+    const hasCRLF = planContent.includes('\r\n');
+    const normalized = normalizeLineEndings(planContent);
+    const sectionLines = findSectionLines(normalized, config.pairingQuestionSection);
+    if (sectionLines.length === 0) {
+        return { updatedContent: planContent, appliedCount: 0 };
+    }
+    const answerMap = new Map();
+    for (const a of answers) {
+        answerMap.set(a.questionId, a);
+    }
+    const lines = normalized.split('\n');
+    const { sectionStart, sectionEnd } = findSectionRange(lines, config.pairingQuestionSection);
+    if (sectionStart === -1) {
+        return { updatedContent: planContent, appliedCount: 0 };
+    }
+    let appliedCount = 0;
+    let currentAnswer;
+    for (let i = sectionStart + 1; i < sectionEnd; i++) {
+        const line = lines[i] ?? '';
+        const trimmed = line.trim();
+        if (trimmed === '')
+            continue;
+        const isTopLevel = !/^\s{2,}/.test(line);
+        if (isTopLevel) {
+            const qMatch = trimmed.match(QUESTION_LINE);
+            if (qMatch?.groups) {
+                const { checked, id } = qMatch.groups;
+                const questionId = (id ?? '').trim();
+                if (isChecked(checked ?? '')) {
+                    currentAnswer = undefined;
+                    continue;
+                }
+                const answer = answerMap.get(questionId);
+                if (answer) {
+                    currentAnswer = answer;
+                    const answerText = answer.selectedOption ?? answer.freeText ?? '';
+                    const updatedLine = line.replace(/\[[ ]*\]/, '[x]').replace(/\s*$/, '');
+                    lines[i] = `${updatedLine} → **답변: ${answerText}**`;
+                    appliedCount++;
+                }
+                else {
+                    currentAnswer = undefined;
+                }
+                continue;
+            }
+        }
+        if (currentAnswer?.selectedOption && /^\s{2,}/.test(line)) {
+            const optMatch = line.match(SUB_OPTION_LINE);
+            if (optMatch?.groups?.optionText) {
+                const rawText = optMatch.groups.optionText.trim();
+                const cleanText = rawText
+                    .replace(/^\s*✅\s*/, '')
+                    .replace(/\s*✅\s*$/, '')
+                    .trim();
+                if (cleanText === currentAnswer.selectedOption && !rawText.includes('✅')) {
+                    lines[i] = `${line} ✅`;
+                }
+            }
+        }
+    }
+    let result = lines.join('\n');
+    if (hasCRLF) {
+        result = result.replace(/\n/g, '\r\n');
+    }
+    return { updatedContent: result, appliedCount };
+}
+/**
+ * 섹션명에 해당하는 라인 범위(시작 헤딩 인덱스, 끝 인덱스)를 찾는다
+ *
+ * findSectionLines와 동일한 매칭 로직을 사용하되,
+ * 라인 인덱스 범위를 반환하여 원본 lines 배열을 직접 수정할 수 있게 한다.
+ */
+function findSectionRange(lines, sectionName) {
+    let sectionStart = -1;
+    let sectionEnd = lines.length;
+    let sectionHeadingLevel = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const trimmed = (lines[i] ?? '').trim();
+        const headingMatch = trimmed.match(/^(#{1,6})\s+(.*)$/);
+        if (sectionStart !== -1 && headingMatch?.[1]) {
+            const level = headingMatch[1].length;
+            if (level <= sectionHeadingLevel) {
+                sectionEnd = i;
+                break;
+            }
+        }
+        if (sectionStart === -1 && headingMatch?.[2]) {
+            const headingText = headingMatch[2].trim();
+            if (headingText.includes(sectionName)) {
+                sectionStart = i;
+                sectionHeadingLevel = (headingMatch[1] ?? '').length;
+            }
+        }
+    }
+    return { sectionStart, sectionEnd };
+}
+//# sourceMappingURL=plan-question-updater.js.map

package/dist/core/resolvers/config-generator.d.ts

@@ -12,8 +12,10 @@ export declare const DEFAULT_ROADMAP_PATH = "vibe/roadmap.md";
 export declare const DEFAULT_PLAN_DIR = "vibe/unit-plans";
 export declare const DEFAULT_RESULT_DIR = "vibe/unit-results";
 export declare const DEFAULT_ID_PATTERN = "^(U-\\d+|CP-).*";
+export declare const DEFAULT_RUNBOOK_DIR = "vibe/unit-runbooks";
 export declare const DEFAULT_COMMAND_SECTION = "# \uC720\uB2DB \uAD6C\uD604";
 export declare const DEFAULT_HEADER_TEMPLATE = "### \uD604\uC7AC \uAD6C\uD604 \uC720\uB2DB: {{title}}\n- \uD604\uC7AC \uAD6C\uD604 \uC720\uB2DB \uAC1C\uBC1C \uACC4\uD68D\uC11C: @{{planPath}}\n- \uD604\uC7AC \uAD6C\uD604 Commit(\uBCC0\uACBD\uC810 \uD655\uC778\uD558\uC5EC \uB9E5\uB77D\uC73C\uB85C \uC0AC\uC6A9): -";
+export declare const SUB_UNIT_HEADER_TEMPLATE = "### \uD604\uC7AC \uC720\uB2DB: {{title}}\n- \uACC4\uD68D\uC11C: @{{planPath}}\n- Commit: -";
 /**
  * 외부 주입 데이터(stdin 등)에서 InitAnswers를 추출한다
  */
@@ -25,8 +27,8 @@ export declare function buildAnswersFromScan(scanResult: ScanResult, overrides?:
 /**
  * InitAnswers → 설정 JSON 객체 구성 (최소 필드)
  *
- * 이 함수는 Zod 스키마에 정의된 기본값들을 제외한 핵심 필드만으로 객체를 구성합니다.
- * 최종 결과는 Zod로 검증하거나 기존 설정과 병합하는 용도로 사용됩니다.
+ * scanResult가 제공되면 감지된 패턴별로 다중 unitType을 생성한다.
+ * 서브유닛 패턴(PREFIX-NNN-XN)이 감지된 prefix는 별도의 unitType으로 분리된다.
  */
-export declare function buildConfigObject(answers: InitAnswers): Record<string, unknown>;
+export declare function buildConfigObject(answers: InitAnswers, scanResult?: ScanResult): Record<string, unknown>;
 //# sourceMappingURL=config-generator.d.ts.map

package/dist/core/resolvers/config-generator.js

@@ -12,8 +12,10 @@ export const DEFAULT_ROADMAP_PATH = 'vibe/roadmap.md';
 export const DEFAULT_PLAN_DIR = 'vibe/unit-plans';
 export const DEFAULT_RESULT_DIR = 'vibe/unit-results';
 export const DEFAULT_ID_PATTERN = '^(U-\\d+|CP-).*';
+export const DEFAULT_RUNBOOK_DIR = 'vibe/unit-runbooks';
 export const DEFAULT_COMMAND_SECTION = '# 유닛 구현';
 export const DEFAULT_HEADER_TEMPLATE = '### 현재 구현 유닛: {{title}}\n- 현재 구현 유닛 개발 계획서: @{{planPath}}\n- 현재 구현 Commit(변경점 확인하여 맥락으로 사용): -';
+export const SUB_UNIT_HEADER_TEMPLATE = '### 현재 유닛: {{title}}\n- 계획서: @{{planPath}}\n- Commit: -';
 /**
  * Record<string, unknown> 오버라이드를 InitAnswers 기본값에 적용한다
  */
@@ -45,7 +47,7 @@ export function extractStdinAnswers(data) {
         roadmapPath: DEFAULT_ROADMAP_PATH,
         planDir: DEFAULT_PLAN_DIR,
         resultDir: DEFAULT_RESULT_DIR,
-        runbookDir: null,
+        runbookDir: DEFAULT_RUNBOOK_DIR,
         idPattern: DEFAULT_ID_PATTERN,
         commandSection: DEFAULT_COMMAND_SECTION,
     };
@@ -77,10 +79,10 @@ export function buildAnswersFromScan(scanResult, overrides) {
 /**
  * InitAnswers → 설정 JSON 객체 구성 (최소 필드)
  *
- * 이 함수는 Zod 스키마에 정의된 기본값들을 제외한 핵심 필드만으로 객체를 구성합니다.
- * 최종 결과는 Zod로 검증하거나 기존 설정과 병합하는 용도로 사용됩니다.
+ * scanResult가 제공되면 감지된 패턴별로 다중 unitType을 생성한다.
+ * 서브유닛 패턴(PREFIX-NNN-XN)이 감지된 prefix는 별도의 unitType으로 분리된다.
  */
-export function buildConfigObject(answers) {
+export function buildConfigObject(answers, scanResult) {
     const docRoots = {
         plan: answers.planDir,
         result: answers.resultDir,
@@ -88,7 +90,10 @@ export function buildConfigObject(answers) {
     if (answers.runbookDir) {
         docRoots['runbook'] = answers.runbookDir;
     }
-    return {
+    const unitTypes = scanResult
+        ? buildUnitTypesFromScan(answers, scanResult, docRoots)
+        : [buildDefaultUnitType(answers)];
+    const config = {
         $schema: 'https://vibe-commander/config-schema.json',
         version: 1,
         paths: {
@@ -96,17 +101,80 @@ export function buildConfigObject(answers) {
             roadmap: answers.roadmapPath,
             docRoots,
         },
-        unitTypes: [
-            {
-                key: 'implement',
-                displayName: '유닛 구현',
-                idPattern: answers.idPattern,
+        unitTypes,
+    };
+    if (unitTypes.length > 1) {
+        config['commandSections'] = { useMarkers: true };
+    }
+    return config;
+}
+function buildDefaultUnitType(answers) {
+    return {
+        key: 'implement',
+        displayName: '유닛 구현',
+        idPattern: answers.idPattern,
+        planDir: 'plan',
+        commandSection: answers.commandSection,
+        collectDeps: true,
+        headerTemplate: DEFAULT_HEADER_TEMPLATE,
+    };
+}
+/**
+ * 스캔 결과의 패턴 정보로 다중 unitType 배열을 구성한다.
+ *
+ * hasSubUnit이 true인 prefix는 서브유닛 타입 + 태그 타입으로 분리되고,
+ * 나머지 prefix는 하나의 implement 타입으로 통합된다.
+ */
+function buildUnitTypesFromScan(answers, scanResult, docRoots) {
+    const unitTypes = [];
+    const implementPrefixes = [];
+    for (const pattern of scanResult.idPatterns) {
+        if (!pattern.hasSubUnit) {
+            implementPrefixes.push(pattern.regex.replace(/^\^/, ''));
+            continue;
+        }
+        const subDir = scanResult.docRoots.find((d) => d.role === 'refactorSub');
+        if (subDir) {
+            docRoots['refactorSub'] = subDir.dirPath;
+        }
+        unitTypes.push({
+            key: `${pattern.prefix.toLowerCase()}-sub`,
+            displayName: `${pattern.prefix} 서브유닛`,
+            idPattern: `^${pattern.prefix}-\\d+-[A-Z]\\d+$`,
+            planDir: subDir ? 'refactorSub' : 'plan',
+            commandSection: `# ${pattern.prefix} 서브유닛`,
+            collectDeps: false,
+            headerTemplate: SUB_UNIT_HEADER_TEMPLATE,
+        });
+        if (pattern.hasTag) {
+            unitTypes.push({
+                key: pattern.prefix.toLowerCase(),
+                displayName: `${pattern.prefix} 유닛`,
+                idPattern: `^${pattern.prefix}-\\d+\\[.*\\]$`,
                 planDir: 'plan',
-                commandSection: answers.commandSection,
+                commandSection: `# ${pattern.prefix} 유닛`,
                 collectDeps: true,
-                headerTemplate: DEFAULT_HEADER_TEMPLATE,
-            },
-        ],
-    };
+                headerTemplate: SUB_UNIT_HEADER_TEMPLATE,
+            });
+        }
+    }
+    if (implementPrefixes.length > 0) {
+        const implPattern = implementPrefixes.length === 1
+            ? `^${implementPrefixes[0] ?? ''}.*`
+            : `^(${implementPrefixes.join('|')}).*`;
+        unitTypes.push({
+            key: 'implement',
+            displayName: '유닛 구현',
+            idPattern: implPattern,
+            planDir: 'plan',
+            commandSection: answers.commandSection,
+            collectDeps: true,
+            headerTemplate: DEFAULT_HEADER_TEMPLATE,
+        });
+    }
+    else if (unitTypes.length === 0) {
+        unitTypes.push(buildDefaultUnitType(answers));
+    }
+    return unitTypes;
 }
 //# sourceMappingURL=config-generator.js.map

package/dist/core/resolvers/config-merger.js

@@ -53,7 +53,6 @@ function mergePaths(existing, scanned) {
         const existingDocRoots = isPlainObject(existing['docRoots']) ? existing['docRoots'] : {};
         const mergedDocRoots = { ...existingDocRoots };
         for (const key of Object.keys(scanned['docRoots'])) {
-            // 스캔 결과에 있는 docRoots 키는 무조건 반영 (갱신 또는 추가)
             mergedDocRoots[key] = scanned['docRoots'][key];
         }
         merged['docRoots'] = mergedDocRoots;

package/dist/types/init.d.ts

@@ -22,6 +22,10 @@ export interface DetectedPattern {
     displayLabel: string;
     matchCount: number;
     examples: string[];
+    /** PREFIX-NNN[Tag] 형태의 태그 파일이 존재하는지 여부 */
+    hasTag: boolean;
+    /** PREFIX-NNN-XN 형태의 서브유닛 파일이 존재하는지 여부 */
+    hasSubUnit: boolean;
 }
 /** 감지된 문서 루트 디렉토리 */
 export interface DetectedDocRoot {

package/examples/commands-template.md

@@ -0,0 +1,53 @@
+<!-- vc:begin:implement -->
+# 유닛 구현
+---------------------------------------------------
+### 현재 구현 유닛: -
+- 현재 구현 유닛 개발 계획서: -
+- 현재 구현 Commit(변경점 확인하여 맥락으로 사용): -
+
+### 의존 유닛 및 기능:
+-
+
+### 의존성 문서:
+-
+
+### 의존성 Commits (변경점 확인하여 맥락으로 사용):
+-
+
+### 특별 요청사항
+-
+---------------------------------------------------
+<!-- vc:end:implement -->
+
+<!-- vc:begin:refactor -->
+# 리펙토링 유닛 제안
+---------------------------------------------------
+### 현재 리펙토링 유닛: -
+- 현재 리펙토링 유닛 제안 계획서: -
+- 현재 리펙토링 Commit(변경점 확인하여 맥락으로 사용): -
+
+### 의존 유닛 및 기능:
+-
+
+### 의존성 문서:
+-
+
+### 의존성 Commits (변경점 확인하여 맥락으로 사용):
+-
+
+### 특별 요청사항
+-
+---------------------------------------------------
+<!-- vc:end:refactor -->
+
+<!-- vc:begin:refactor-sub -->
+# 리펙토링 유닛 구현
+---------------------------------------------------
+### 현재 리펙토링 유닛: -
+- 현재 리펙토링 유닛 제안 계획서: -
+- 현재 리펙토링 Commit(변경점 확인하여 맥락으로 사용): -
+
+### 특별 요청사항
+-
+---------------------------------------------------
+<!-- vc:end:refactor-sub -->

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-commander",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "type": "module",
   "description": "Unit-based vibe coding workflow automation CLI — automate context collection from unit ID to command file in 10 seconds",
   "license": "MIT",