elanous 0.2.35 → 0.2.37

package/src/self-implement/goal-author-decompose.ts

@@ -7,6 +7,7 @@ import { getDefaultLogStore } from '../mss/logging/log-store.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { selectPlanningLlm } from '../prompt-enhance/enhance.js';
 import type { GoalAuthorDeps } from './goal-author.js';
+import { ensureDeviceFirstSteps } from './device-first.js';
 
 const GOAL_STEPS_DECOMPOSED_EVENT = 'goal-steps-decomposed';
 
@@ -21,6 +22,7 @@ export interface SizedSlice {
   newFiles: number;
   tier: SliceTier;
   unavoidable?: string;
+  deviceFirst?: 'device-test' | 'feature';
 }
 export type TierSizedDecomposeResult =
   | { ok: true; slices: SizedSlice[]; redecomposed: number }
@@ -31,6 +33,10 @@ function publicSizedSlices(steps: readonly string[], sizes: readonly GoalSliceSi
     const size = sizes[index]!;
     return { goal, files: size.files, behaviours: size.actions, newFiles: size.newFiles,
       tier: ({ low: '하', medium: '중', high: '상' } as const)[size.tier],
+      ...(/(?:^|\n|·\s*)동작:\s*DEVICE-FIRST-STAGE\b/u.test(goal)
+        ? { deviceFirst: 'device-test' as const }
+        : /(?:^|\n)선행:\s*DEVICE-FIRST-STAGE 조각 착지 뒤 발사(?:$|\n)/u.test(goal)
+          ? { deviceFirst: 'feature' as const } : {}),
       ...(size.unavoidableReason ? { unavoidable: size.unavoidableReason } : {}) };
   });
 }
@@ -72,6 +78,23 @@ function expectedSliceTier(files: number, actions: number, newFiles: number): Go
   return 'high';
 }
 
+/**
+ * 경계 분기(1 step ⊕ acceptance 3)의 크기 메타 — 경계 step 은 쪼개지 않고 «한 조각»으로 잰다.
+ * 동작 수는 1(묶은 step 자체)이고 상 로 갈리면 불가분 사유를 싣는다(완료 경계 3행은 acceptance 셋이라
+ * 나누면 코드 없는 실물·증거 조각이 생긴다).
+ */
+function boundaryStepSize(step: string, rows: readonly CompletionBoundaryRow[]): GoalSliceSize {
+  const paths = new Set<string>();
+  for (const row of rows) for (const path of row.paths) paths.add(path);
+  for (const match of step.matchAll(/(?:^|[\s`·,()])([\w.@-]+(?:\/[\w.@-]+)+\.[A-Za-z][\w-]*)/gu)) paths.add(match[1]!);
+  const files = Math.max(1, paths.size);
+  const tier = expectedSliceTier(files, 1, 0);
+  return { files, actions: 1, newFiles: 0, tier,
+    unavoidableReason: tier === 'high'
+      ? '완료 경계 3행은 한 step 의 acceptance 셋 — 나누면 코드 없는 실물·증거 조각이 생긴다.'
+      : null };
+}
+
 /** Estimates are observations from the planner, checked against the declared tier before they guide retry. */
 function parseGoalSliceSizes(raw: string, count: number): GoalSliceSize[] | null {
   try {
@@ -253,6 +276,195 @@ export function classifyShadowFirstSplit(objective: string): ShadowFirstSplitVer
   return { kind: 'single-piece' };
 }
 
+/**
+ * ⭐ DECOMPOSE-BOUNDARY-ONE-STEP(MK · 0.2.36) — 완료 경계 3행(코드 · 실물 · 증거 명령)은 «세 조각»이 아니라
+ *   한 step 의 acceptance 셋이다. 종전에는 경계 행이 문면에 그대로 있어도 LLM 쪼개기가 행마다 조각을 만들어
+ *   «코드 없는 증거 조각»·«라이브 조각»이 생겼고, 그 조각들은 구현할 것이 없어 손으로 닫아야 했다
+ *   (실측 10-17 UX 미션 ta-20261016-ddf426 · ta-20261016-179cbb).
+ * 판정은 순수 규칙이다 — 골 문면에서 `완료 경계 코드:`·`완료 경계 실물:`·`완료 경계 증거 명령:` 세 줄을 읽고,
+ *   셋이 다 있으면 step 1 ⊕ acceptance 3 으로 묶는다. 둘 이하면 종전 경로 그대로(동작 0 변화).
+ * 결과는 «직렬 카드 셋»(step 카드 + 경계 카드)으로도 나온다 — 코드 경로가 없는 실물·증거 행은
+ *   코드 없는 live/evidence 카드로 남는다(그 카드가 조각으로 승격되지 않는다는 것이 이 판정의 요점).
+ */
+export const COMPLETION_BOUNDARY_LABELS = {
+  code: '완료 경계 코드',
+  live: '완료 경계 실물',
+  'evidence-command': '완료 경계 증거 명령',
+} as const;
+
+export type CompletionBoundaryKind = keyof typeof COMPLETION_BOUNDARY_LABELS;
+
+export type CompletionBoundaryRow = {
+  kind: CompletionBoundaryKind;
+  label: string;
+  /** 라벨 뒤 값 — 문면 그대로. */
+  text: string;
+  /** `완료 경계 코드` 행에서만 채운다(실물·증거 명령 행은 코드 없는 카드다). */
+  paths: readonly string[];
+  /** `완료 경계 증거 명령` 행에서만 채운다 — 명령 원문 그대로. */
+  command?: string;
+};
+
+export type GoalDecomposeCard = {
+  kind: 'step' | 'acceptance' | 'live' | 'evidence';
+  id: string;
+  title: string;
+  body: string;
+  paths?: readonly string[];
+  command?: string;
+};
+
+export type GoalDecomposeResult = {
+  /** 경계 3행을 step 1 ⊕ acceptance 3 으로 묶었나. */
+  bundled: boolean;
+  rows: readonly CompletionBoundaryRow[];
+  steps: readonly string[];
+  acceptance: readonly string[];
+  cards: readonly GoalDecomposeCard[];
+};
+
+const COMPLETION_BOUNDARY_LINE = /^\s*(?:[-*+]\s+|\d+[.)]\s+|>\s*)?완료\s*경계\s*(코드|실물|증거\s*명령)\s*[:：]\s*(.+?)\s*$/u;
+const COMPLETION_BOUNDARY_KIND_BY_TOKEN: Record<string, CompletionBoundaryKind> = {
+  코드: 'code',
+  실물: 'live',
+  증거명령: 'evidence-command',
+};
+
+export const COMPLETION_BOUNDARY_STEP_PREFIX =
+  '① 완료 경계 3행(코드·실물·증거 명령) 한 step — 경계 행은 조각이 아니라 이 step 의 acceptance 다';
+
+function completionBoundaryPaths(text: string): string[] {
+  const paths: string[] = [];
+  for (const match of text.matchAll(/(?:^|[\s`·,()])((?:[\w.@-]+\/)+[\w.@-]+\.[A-Za-z][\w-]*)/gu)) {
+    const path = match[1]!;
+    if (!paths.includes(path)) paths.push(path);
+  }
+  return paths;
+}
+
+/** 골 문면의 완료 경계 행 — 종류마다 첫 줄 하나(중복 라벨은 첫 줄이 이긴다). */
+export function parseCompletionBoundaryRows(goal: string): CompletionBoundaryRow[] {
+  const rows: CompletionBoundaryRow[] = [];
+  const seen = new Set<CompletionBoundaryKind>();
+  for (const line of goal.split(/\r?\n/)) {
+    const match = COMPLETION_BOUNDARY_LINE.exec(line);
+    if (!match) continue;
+    const kind = COMPLETION_BOUNDARY_KIND_BY_TOKEN[match[1]!.replace(/\s+/gu, '')];
+    if (!kind || seen.has(kind)) continue;
+    const text = match[2]!.trim();
+    if (!text) continue;
+    seen.add(kind);
+    rows.push({
+      kind,
+      label: COMPLETION_BOUNDARY_LABELS[kind],
+      text,
+      paths: kind === 'code' ? completionBoundaryPaths(text) : [],
+      ...(kind === 'evidence-command' ? { command: text } : {}),
+    });
+  }
+  return rows;
+}
+
+/**
+ * 경계 3행 골도 «장치 먼저» RED 단계를 피하지 않는다 — 다만 그 단계를 별도 조각(step 2)으로 만들지
+ * 않고 «같은 런의 첫 동작» 으로 다시 써 이 step 안에 접어 넣는다(판정선: step 1 ⊕ acceptance 3).
+ *
+ * ⭐ must-fix(b) — 접힌 문면에서 다음 셋을 뺀다:
+ *   ⑴ «운영 코드 변경 0» — 기능을 구현하라는 step 에 «운영 코드 변경 0» 을 섞으면 자식이 모순 지시를 받는다.
+ *   ⑵ «선행: DEVICE-FIRST-STAGE 조각 착지 뒤 발사» — 자기 자신(이 step)을 선행으로 기다리라는 문구다.
+ *   ⑶ «동작: DEVICE-FIRST-STAGE» 표지 — 이 표지가 남으면 `publicSizedSlices` 가 접힌 조각을
+ *      `deviceFirst:'device-test'` 로 분류하고, `handTaskWithTierSplit` 이 «장치 시험 카드» 미션만
+ *      발사해 기능 카드가 0장이 된다(결함을 `outcome:'device-first-deferred'` 로 정답 처리하던 원전).
+ */
+/** 접힌 경계 step 이 «장치 RED 를 같은 런의 첫 동작으로 싣고 있다»는 표지 — goal-author 의 재-staging 이 이를 알아본다. */
+export const FOLDED_DEVICE_FIRST_ACTION_MARKER = '첫 동작(같은 런)';
+
+function foldDeviceStageIntoBoundaryStep(goal: string, step: string, root?: string): string {
+  const staged = ensureDeviceFirstSteps(goal, [step], root);
+  if (staged.steps.length <= 1) {
+    // A boundary goal still starts with RED inside its single feature slice. Use
+    // the test path supplied by the completion boundary; never invent a device.
+    const rows = parseCompletionBoundaryRows(goal);
+    const declaredTest = [rows.find((row) => row.kind === 'evidence-command'), rows.find((row) => row.kind === 'code')]
+      .filter((row): row is CompletionBoundaryRow => row !== undefined)
+      .flatMap((row) => completionBoundaryPaths(row.text))
+      .find((path) => /\.(?:test|spec)\.[cm]?[jt]sx?$/u.test(path));
+    const firstAction = declaredTest
+      ? `${FOLDED_DEVICE_FIRST_ACTION_MARKER}: 완료 경계에 적힌 ${declaredTest}의 존재를 확인한다. 기존이면 mock 무대 시험 RED를 먼저 기록하고, 없으면 새 경로를 짐작하지 말고 신설: 선언 뒤 같은 시험의 RED를 기록한다.`
+      : `${FOLDED_DEVICE_FIRST_ACTION_MARKER}: 시험 경로 미확정 — 골의 증거 명령에서 시험 경로를 정한 뒤 mock 무대 시험 RED를 기록한다.`;
+    return `${firstAction} ⇒ ${step.replace(/\r?\n/gu, ' ')}`;
+  }
+  const decision = staged.decision;
+  const test = decision.device.replace(/\.ts$/u, '.test.ts');
+  const inventory = decision.inventoryMeasured
+    ? (decision.exists
+      ? `기존 ${decision.device} 를 써서`
+      : `신규 ${decision.device} 를 만들어`)
+    : `장치 재고를 대상 저장소에서 먼저 확인한 뒤 기존 장치를 쓰거나 없으면 ${decision.device} 로 새로 만들어`;
+  const deviceAction = `${FOLDED_DEVICE_FIRST_ACTION_MARKER}: ${inventory} ${test} 의 mock 무대 시험 RED 를 먼저 기록한다.`;
+  // «step 한 줄» 불변식 유지 — 원 step 의 개행을 치환해 붙인다(선행 문구는 아예 더하지 않는다).
+  return `${deviceAction} ⇒ ${step.replace(/\r?\n/gu, ' ')}`;
+}
+
+function bundledCompletionBoundaryStep(rows: readonly CompletionBoundaryRow[]): string {
+  return `${COMPLETION_BOUNDARY_STEP_PREFIX}: ${rows
+    .map((row, index) => `acceptance ${index + 1}[${row.label}] ${row.text}`)
+    .join(' ⇒ ')}`;
+}
+
+function completionBoundaryCards(rows: readonly CompletionBoundaryRow[], step: string): GoalDecomposeCard[] {
+  const codePaths = rows.find((row) => row.kind === 'code')?.paths ?? [];
+  const cards: GoalDecomposeCard[] = [
+    { kind: 'step', id: 'step-1', title: 'step 1 — 완료 경계 3행 한 step', body: step, paths: codePaths },
+  ];
+  for (const row of rows) {
+    if (row.kind === 'code') {
+      cards.push({ kind: 'acceptance', id: 'acceptance-code', title: row.label, body: row.text, paths: row.paths });
+      continue;
+    }
+    if (row.kind === 'live') {
+      cards.push({ kind: 'live', id: 'acceptance-live', title: row.label, body: row.text });
+      continue;
+    }
+    cards.push({ kind: 'evidence', id: 'acceptance-evidence-command', title: row.label, body: row.text,
+      ...(row.command === undefined ? {} : { command: row.command }) });
+  }
+  return cards;
+}
+
+/**
+ * 골 문면 → 직렬 카드 셋. `bundling: false` 는 반증 스위치다 — 같은 문면이 step 3 개로 흩어지는 모습을
+ * 시험이 그대로 만들 수 있게 한다(생산 경로는 이 스위치를 끄지 않는다).
+ */
+export function decomposeGoal(goal: string, options: { bundling?: boolean } = {}): GoalDecomposeResult {
+  const rows = parseCompletionBoundaryRows(goal);
+  if (!rows.length) return { bundled: false, rows, steps: [], acceptance: [], cards: [] };
+  if (options.bundling === false) {
+    return {
+      bundled: false,
+      rows,
+      steps: rows.map((row) => `${row.label}: ${row.text}`),
+      acceptance: [],
+      cards: rows.map((row, index) => ({
+        kind: 'step',
+        id: `step-${index + 1}`,
+        title: `step ${index + 1} — ${row.label}`,
+        body: `${row.label}: ${row.text}`,
+        ...(row.kind === 'code' ? { paths: row.paths } : {}),
+      })),
+    };
+  }
+  if (rows.length < 3) return { bundled: false, rows, steps: [], acceptance: [], cards: [] };
+  const step = bundledCompletionBoundaryStep(rows);
+  return {
+    bundled: true,
+    rows,
+    steps: [step],
+    acceptance: rows.map((row) => `${row.label}: ${row.text}`),
+    cards: completionBoundaryCards(rows, step),
+  };
+}
+
 /** Shared LLM-backed decomposition seam for every goal-author entrypoint. */
 export function createGoalAuthorDecomposeSteps(
   signal?: AbortSignal,
@@ -261,6 +473,7 @@ export function createGoalAuthorDecomposeSteps(
     adversarialReviewSource?: 'cli' | 'default' | 'unknown';
     recentStepCounts?: readonly number[];
     onSizedSlices?: (slices: SizedSlice[], redecomposed: number) => void;
+    repositoryRoot?: string;
   } = {},
 ): NonNullable<GoalAuthorDeps['decomposeSteps']> {
   return async (objective, options) => {
@@ -301,6 +514,42 @@ export function createGoalAuthorDecomposeSteps(
           : '자연어 요청(그림자 우선 어휘 ⊕ 분할 지시) — 그림자 우선 두 조각(선행 간선 1).',
       );
     }
+    // ⭐ DECOMPOSE-BOUNDARY-ONE-STEP — 완료 경계 3행이 다 있는 골은 LLM 쪼개기 «전에» 한 step 으로 묶는다.
+    //   묶지 않으면 행마다 조각이 생겨 «코드 없는 증거/라이브 조각»이 나온다(실측 10-17 UX 미션 2건 손마감).
+    const boundary = decomposeGoal(objective);
+    if (boundary.bundled) {
+      try {
+        debug.log('goal-author', 'completion-boundary-bundled', {
+          surface: 'goal-author',
+          verdict: 'one-step-three-acceptance',
+          boundaryKind: 'completion-boundary',
+          rows: boundary.rows.map((row) => row.kind),
+          cards: boundary.cards.map((card) => card.kind),
+          steps: boundary.steps.length,
+          acceptance: boundary.acceptance.length,
+          ...(options?.runId === undefined ? {} : { runId: options.runId }),
+        });
+      } catch { /* observation is fail-soft */ }
+      // ⭐ 경계 분기도 finish() 와 같은 계약으로 크기 메타를 만들어 onSizedSlices 를 부른다
+      //   (1조각 SizedSlice · restoreSlicePaths 포함 · redecomposed 0). 우회하면 생산 소비자
+      //   `decomposeToTierSizedSlices`(tier-split 기본 seam)이 «no sized slices» 로 막힌다.
+      const boundarySteps = boundary.steps.map((step) => foldDeviceStageIntoBoundaryStep(objective, step, config.repositoryRoot));
+      const boundarySizes = boundarySteps.map((step) => boundaryStepSize(step, boundary.rows));
+      const declaredTargetLine = objective.split(/\r?\n/u)
+        .map((line) => line.trim())
+        .find((line) => /^대상\s*경로\s*[:：]/u.test(line));
+      const boundarySlices = restoreSlicePaths(publicSizedSlices(boundarySteps, boundarySizes), objective);
+      // The authored step stays one line. The handed slice must start with the parent's
+      // declared target line: preflight reads only that line before tracing paths.
+      config.onSizedSlices?.(declaredTargetLine
+        ? boundarySlices.map((slice) => ({ ...slice, goal: slice.goal.startsWith(declaredTargetLine)
+          ? slice.goal : `${declaredTargetLine}\n${slice.goal}` }))
+        : boundarySlices, 0);
+      return finalize(
+        boundarySteps,
+        '완료 경계 3행(코드·실물·증거 명령) — step 1 의 acceptance 3 으로 묶음(경계 행은 조각이 아니다).',
+      );
+    }
     const { streamLLM } = await import('../llm.js');
     // ⭐ AUTHOR-DECOMPOSE-KNOB(0.2.24 · G7 #25848) — 쪼개기·적대 비평의 두 streamLLM 호출이 인핸서와
     //   «같은 규칙»으로 planning 노브(roleLlm.planning ⊕ ELANOUS_PROMPT_ENHANCE_MODEL/EFFORT)를 따른다.
@@ -321,8 +570,19 @@ export function createGoalAuthorDecomposeSteps(
       );
     };
     const steps = await decompose(objective);
-    const finish = async (candidate: string[], rationale?: string): Promise<string[]> => {
-      if (!candidate.length) return finalize(candidate, rationale);
+    const finish = async (rawCandidate: string[], rationale?: string): Promise<string[]> => {
+      if (!rawCandidate.length) return finalize(rawCandidate, rationale);
+      const staged = ensureDeviceFirstSteps(objective, rawCandidate, config.repositoryRoot);
+      let candidate = staged.steps;
+      if (staged.decision.required) {
+        try { debug.log('self-implement.decompose', 'device-first-slice', {
+          runId: options?.runId ?? null, firstSliceKind: staged.decision.firstSliceKind,
+          deviceCandidates: [staged.decision.device], deviceSource: staged.decision.deviceSource,
+          deviceExists: staged.decision.exists,
+          inventoryMeasured: staged.decision.inventoryMeasured,
+          featureSlices: Math.max(0, candidate.length - 1),
+        }); } catch { /* observation is fail-soft */ }
+      }
       const measure = async (slices: string[]) => {
         const parsed = parseGoalSliceSizes(await streamLLM(
           [{ role: 'user', content: goalSliceSizePrompt(objective, slices) }], () => {}, llmOpts), slices.length);
@@ -350,7 +610,7 @@ export function createGoalAuthorDecomposeSteps(
         const regenerated = await decompose(retryAsk);
         if (!regenerated.length) throw new Error('goal-author slice sizing: regeneration produced no slices');
         redecomposed = 1;
-        candidate = regenerated;
+        candidate = ensureDeviceFirstSteps(objective, regenerated, config.repositoryRoot).steps;
         rationale = decompositionRationale;
         measured = await measure(candidate);
         sizes = measured.sizes;
@@ -438,12 +698,13 @@ export function createGoalAuthorDecomposeSteps(
 /** Public goal-author sizing seam for a hand caller that needs per-slice tier metadata. */
 export async function decomposeToTierSizedSlices(
   goal: string,
-  opts?: { signal?: AbortSignal },
+  opts?: { signal?: AbortSignal; repositoryRoot?: string },
 ): Promise<TierSizedDecomposeResult> {
   let result: { slices: SizedSlice[]; redecomposed: number } | undefined;
   try {
     const steps = await createGoalAuthorDecomposeSteps(opts?.signal, {
       adversarialReview: false,
+      ...(opts?.repositoryRoot ? { repositoryRoot: opts.repositoryRoot } : {}),
       onSizedSlices: (slices, redecomposed) => { result = { slices, redecomposed }; },
     })(goal);
     if (!steps.length || !result) return { ok: false, reason: 'goal-author slice sizing: no sized slices' };