elanous 0.2.15 → 0.2.17

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

@@ -1,9 +1,11 @@
 import { readFileSync, realpathSync } from 'node:fs';
+import { writeGoalDocumentAtomic } from './goal-document-write.js';
 import { isAbsolute, relative, resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
 import { parseAskProseTitle } from '../self-dev/launch-preflight.js';
 import { createGoalAuthorDecomposeSteps, readRecentStepCountsFailOpen, type RecentStepCountReader } from './goal-author-decompose.js';
-import { defaultGoalAuthorSelfResolve, parseGoalDocumentClarifications, seedGoalAuthorFromAnsweredClarification, seedGoalAuthorFromClarification } from './goal-author-clarification.js';
+import { defaultGoalAuthorSelfResolve, parseGoalDocumentClarifications, seedGoalAuthorFromAnsweredClarification, seedGoalAuthorFromClarification, selfAnswerGoalDocumentClarifications } from './goal-author-clarification.js';
 import { classifyGoalInterviewRound, type GoalInterviewRoundStatus } from './goal-author-closure.js';
 import { recordGoalAsk } from './goal-ask-store.js';
 import { pressDecisionSignal } from './decision-signal-press.js';
@@ -15,6 +17,8 @@ import {
   verbatimOriginalAsk,
   writeAuthoredGoal,
   type GoalAuthorDeps,
+  type GoalAuthorGradeSelection,
+  resolveGoalAuthorGrade,
   type GoalType,
   type GoalFileLintFinding,
 } from './goal-author.js';
@@ -77,6 +81,7 @@ interface GoalAuthorCliOptions {
   supersedes?: string;
   rootIntent?: string;
   goalType?: string;
+  authorGrade?: GoalAuthorGradeSelection;
   selfResolveClarifications?: boolean;
   adversarialReview?: boolean;
   disableAdversarialReview?: boolean;
@@ -97,6 +102,7 @@ export interface GoalAuthorCliDeps {
   recentStepCountReader?: RecentStepCountReader;
   /** Resolver supplied only by the explicit CLI self-resolution opt-in. */
   selfResolveClarification?: NonNullable<GoalAuthorDeps['selfResolveClarification']>;
+  writeFile?: (path: string, document: string) => void;
   recordAsk?: typeof recordGoalAsk;
 }
 
@@ -268,8 +274,9 @@ export async function runGoalAuthorCli(
     : opts.reauthorFromAnsweredClarification
       ? { origin: 'answered-clarification-reauthor' }
       : { origin: 'direct-request' };
-  const recentStepCounts = readRecentStepCountsFailOpen(deps.recentStepCountReader);
-  const decomposeSteps = deps.decomposeSteps ?? (deps.createDecomposeSteps ?? createGoalAuthorDecomposeSteps)(undefined, {
+  const authorGrade = opts.authorGrade ?? resolveGoalAuthorGrade(undefined, getUserConfig().harness?.authorGrade);
+  const recentStepCounts = authorGrade.grade === 'lite' ? undefined : readRecentStepCountsFailOpen(deps.recentStepCountReader);
+  const decomposeSteps = authorGrade.grade === 'lite' ? undefined : deps.decomposeSteps ?? (deps.createDecomposeSteps ?? createGoalAuthorDecomposeSteps)(undefined, {
     ...(adversarialReview !== undefined ? { adversarialReview, adversarialReviewSource: 'cli' as const } : {}),
     ...(recentStepCounts !== undefined ? { recentStepCounts } : {}),
   });
@@ -283,13 +290,34 @@ export async function runGoalAuthorCli(
   debug.log('goal-author', 'goal-title-forwarded', proseTitle === undefined
     ? { passed: false }
     : { passed: true, titleChars: proseTitle.length });
+  const gradeDeps = authorGrade.grade === 'lite' || opts.authorGrade ? { authorGrade } : {};
   const authorDeps: Partial<GoalAuthorDeps> = parentGoalFile && parentQuestionId
-    ? { parent: { goalFile: parentGoalFile, questionId: parentQuestionId }, parentDocument, clarificationAnswers, decomposeSteps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps }
-    : { ...(clarificationAnswers && { clarificationAnswers }), decomposeSteps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps };
+    ? { parent: { goalFile: parentGoalFile, questionId: parentQuestionId }, parentDocument, clarificationAnswers, ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps }
+    : { ...(clarificationAnswers && { clarificationAnswers }), ...(decomposeSteps ? { decomposeSteps } : {}), ...gradeDeps, ...selfResolutionDeps, ...progressDeps, ...launchPreflightDeps, ...(opts.rootIntent !== undefined && { rootIntent: opts.rootIntent }), ...(goalType !== undefined && { goalType }), ...goalTitleDeps };
   const write = deps.write ?? writeAuthoredGoal;
   const result = opts.groundingCwd === undefined
     ? await write(ask, opts.cwd, authorDeps, superseded ? { supersedes: superseded } : undefined)
     : await write(ask, opts.cwd, authorDeps, superseded ? { supersedes: superseded } : undefined, opts.groundingCwd);
+  if (opts.selfResolveClarifications) {
+    const rework = Boolean(supersededDocument || opts.reauthorFromAnsweredClarification);
+    {
+      try {
+        const resolved = await selfAnswerGoalDocumentClarifications(result.authored.document, {
+          path: rework ? 'rework' : 'say-first', ask, resolver: deps.selfResolveClarification ?? defaultGoalAuthorSelfResolve,
+          evidence: result.authored.facts
+            ? [...(result.authored.facts.persistentEvidence ?? []), ...result.authored.facts.codeFacts, ...result.authored.facts.documentFacts]
+            : undefined,
+        });
+        if (resolved.newlyAnswered > 0) {
+          (deps.writeFile ?? writeGoalDocumentAtomic)(result.path, resolved.document);
+          result.authored.document = resolved.document;
+        }
+      } catch (error) {
+        // The previous goal file is left intact (atomic replace); implementation proceeds from it with the questions deferred.
+        debug.log('goal-author.clarify', 'self-answer-deferred', { reason: error instanceof Error ? error.message : String(error) });
+      }
+    }
+  }
   try {
     const recorded = (deps.recordAsk ?? recordGoalAsk)({
       authorRunId: result.authored.authorRunId,

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

@@ -18,6 +18,17 @@ function observeGoalAuthor(
   debug.log(category === 'goal-author' ? 'harness.author' : 'harness.author.clarify', event, data);
 }
 import { getUserConfig } from '../user-config.js';
+
+export type GoalAuthorGrade = 'full' | 'lite';
+export type GoalAuthorGradeSource = 'flag' | 'config' | 'default';
+export interface GoalAuthorGradeSelection { grade: GoalAuthorGrade; source: GoalAuthorGradeSource }
+
+/** The flag is authoritative; malformed or absent configuration keeps the full pipeline. */
+export function resolveGoalAuthorGrade(flag?: GoalAuthorGrade, configured?: unknown): GoalAuthorGradeSelection {
+  if (flag !== undefined) return { grade: flag, source: 'flag' };
+  if (configured === 'lite' || configured === 'full') return { grade: configured, source: 'config' };
+  return { grade: 'full', source: 'default' };
+}
 import type { ObserveOnlySource } from './observe-only.js';
 import type { Question } from '../ask-user-question/types.js';
 import { requestTestScenario as defaultRequestTestScenario, type TestScenarioRequestInput, type TestScenarioRequestResult } from './test-scenario-request.js';
@@ -45,6 +56,7 @@ type GoalEnhancement = Omit<Pick<EnhanceResult, 'original' | 'checklist' | 'verb
 export interface GoalAuthorDeps {
   ground: (ask: string, groundingDeps?: GoalAuthorGroundingDeps) => Promise<CodebaseGrounding>;
   persistentGrounding?: GoalAuthorGroundingDeps;
+  authorGrade?: GoalAuthorGradeSelection;
   enhance: (ask: string, opts?: EnhanceOpts) => Promise<GoalEnhancement>;
   /** Additive enhancer options supplied by the file-writing entrypoint. */
   enhanceOpts?: EnhanceOpts;
@@ -4925,6 +4937,17 @@ async function authorGoalWithSupersededRootIntent(
   }
   // ⭐ 이 저작 «한 번»의 id. goalId 보다 «먼저» 있어야 ground·enhance 의 소요를 그 골에 붙일 수 있다.
   const authorRunId = generateGoalId();
+  const authorGrade = deps.authorGrade ?? resolveGoalAuthorGrade(undefined, getUserConfig().harness?.authorGrade);
+  const lite = authorGrade.grade === 'lite';
+  // lite 는 판정선을 남기는 대신 단계를 덜 한다 — 요청에 반증 줄이 하나도 없으면 판정선 없는 골이 나가므로 시작 전에 멈춘다.
+  if (lite && !ask.split(/\r?\n/u).some((line) => /판정선|판정 신호|반증|decision signal/iu.test(line))) {
+    try { observeGoalAuthor('goal-author', 'author-grade-refused', { authorRunId, reason: 'lite-without-falsifiable-signal' }); }
+    catch { /* observation is fail-soft */ }
+    throw new Error('lite authoring needs a falsifiable signal line (판정선/반증) in the ask — add one or use --author-grade full');
+  }
+  const skippedPhases = lite ? ['adversarial-review', 'goal-steps-decomposed', 'persistent-grounding'] : [];
+  try { observeGoalAuthor('goal-author', 'author-grade', { authorRunId, grade: authorGrade.grade, source: authorGrade.source, skippedPhases }); }
+  catch { /* observation is fail-soft */ }
   const authorStartedAt = Date.now();
   const enhanceTokens: GoalAuthorTokens = { inputTokens: null, outputTokens: null };
   const onEnhanceUsage = (usage: LLMUsage): void => {
@@ -4934,18 +4957,20 @@ async function authorGoalWithSupersededRootIntent(
   };
   let facts: CodebaseGrounding | null = null;
   let groundingError = false;
-  const persistentGrounding = resolveGoalAuthorPersistentGrounding('persistentGrounding' in deps ? deps.persistentGrounding : undefined);
-  const groundStartedAt = startGoalAuthorPhase('ground', authorRunId, deps.onProgress);
-  try {
-    facts = await deps.ground(ask, persistentGrounding.deps);
-  } catch {
-    groundingError = true;
-  } finally {
-    endGoalAuthorPhase('ground', groundStartedAt, authorRunId, deps.onProgress);
-    observeGoalAuthorPersistentGroundingResult(
-      persistentGrounding.decision,
-      goalAuthorPersistentGroundingMetrics(facts, groundingError, authorRunId),
-    );
+  if (!lite) {
+    const persistentGrounding = resolveGoalAuthorPersistentGrounding('persistentGrounding' in deps ? deps.persistentGrounding : undefined);
+    const groundStartedAt = startGoalAuthorPhase('ground', authorRunId, deps.onProgress);
+    try {
+      facts = await deps.ground(ask, persistentGrounding.deps);
+    } catch {
+      groundingError = true;
+    } finally {
+      endGoalAuthorPhase('ground', groundStartedAt, authorRunId, deps.onProgress);
+      observeGoalAuthorPersistentGroundingResult(
+        persistentGrounding.decision,
+        goalAuthorPersistentGroundingMetrics(facts, groundingError, authorRunId),
+      );
+    }
   }
 
   const enhanceStartedAt = startGoalAuthorPhase('enhance', authorRunId, deps.onProgress);
@@ -4989,6 +5014,57 @@ async function authorGoalWithSupersededRootIntent(
   }
   enhancement = { ...enhancement, original: ask };
 
+  if (lite) {
+    const goalType = deps.goalType ?? 'implement';
+    const goalId = deps.goalId ?? generateGoalId();
+    const signal = decisionSignalSection(null, ask, enhancement.decisionSignal);
+    const falsifiableSignal = signal.filled > 0 ? signal.lines : [
+      ...signal.lines,
+      ...ask.split(/\r?\n/u).filter((line) => /판정선|판정 신호|반증|decision signal/iu.test(line) && !signal.lines.some((rendered) => rendered.includes(line.trim()))),
+    ];
+    const targetPaths = [...new Set(declaredTargetPaths(ask))];
+    const checklistIds = [...new Set(Array.from(ask.matchAll(/\b[A-Z][A-Z0-9]+-[A-Z0-9]+\b/g), (match) => match[0]))];
+    const askFile = deps.askFile === undefined ? undefined : validateAskFile(deps.askFile);
+    const inheritedRootIntent = deps.parentDocument === undefined ? null : parseRootIntent(deps.parentDocument);
+    const rootIntent = validateRootIntent(deps.supersessionRootIntent ?? inheritedRootIntent ?? deps.rootIntent ?? goalSummary(ask));
+    const document = [
+      deps.goalTitle ?? goalSummary(ask),
+      `- GoalId: ${goalId}`,
+      `- RootIntent: ${rootIntent}`,
+      `- GoalType: ${goalType}`,
+      ...(askFile === undefined ? [] : [`- AskFile: ${askFile}`]),
+      '',
+      '## PROBLEM',
+      `- 왜: ${enhancement.complication ?? goalSummary(ask)}`,
+      '',
+      '## WHAT TO BUILD',
+      `- 무엇: ${enhancement.situation ?? goalSummary(ask)}`,
+      ORIGINAL_ASK_MARKER,
+      fenceFor(ask), ask, fenceFor(ask),
+      '',
+      '## ACCEPTANCE CRITERIA',
+      ...enhancement.checklist.map(requestedCriterionLine),
+      '',
+      '## REQUIRED EVIDENCE',
+      '- [requested] Verify the decision signal and the verbatim ask.',
+      '',
+      ...(goalType === 'implement' ? ['## TRACED PATHS', ...(targetPaths.length ? targetPaths.map((path) => `- ${path}`) : ['- Target paths: not declared in the ask.']), ''] : []),
+      '## SCOPE BOUNDARY',
+      `- 대상 경로: ${targetPaths.length ? targetPaths.join(' · ') : 'not declared'}`,
+      `- 칸 id: ${checklistIds.length ? checklistIds.join(' · ') : 'not declared'}`,
+      '',
+      '## 답하지 못하는 것',
+      '- No persistent grounding was performed in lite authoring.',
+      '',
+      '## 불변식',
+      '- No persistent grounding was performed in lite authoring.',
+      '',
+      '## 판정 신호',
+      ...falsifiableSignal,
+    ].join('\n');
+    return { document, facts: null, grounded: false, authorRunId };
+  }
+
   observeGoalAuthor('goal-author', 'constant-instruction-placement', {
     authorRunId,
     lines: CONSTANT_DOCUMENT_INSTRUCTION_POLICY.length,
@@ -5452,23 +5528,29 @@ async function authorGoalWithSupersededRootIntent(
     assembleCompleted = true;
     endGoalAuthorPhase('assemble', assembleStartedAt, authorRunId, deps.onProgress);
     const lintStartedAt = startGoalAuthorPhase('lint', authorRunId, deps.onProgress);
+    let lintPassed = false;
     try {
       assertRequiredBlocks(document);
+      lintPassed = true;
     } finally {
-      endGoalAuthorPhase('lint', lintStartedAt, authorRunId, deps.onProgress);
+      try {
+        endGoalAuthorPhase('lint', lintStartedAt, authorRunId, deps.onProgress);
+      } finally {
+        try {
+          observeGoalAuthor('goal-author', 'summary', {
+            authorRunId,
+            elapsedMs: Date.now() - authorStartedAt,
+            inputTokens: enhanceTokens.inputTokens,
+            outputTokens: enhanceTokens.outputTokens,
+            totalTokens: enhanceTokens.inputTokens === null || enhanceTokens.outputTokens === null
+              ? null : enhanceTokens.inputTokens + enhanceTokens.outputTokens,
+            goalChars: [...document].length,
+            sectionChars: authoredGoalSectionChars(document),
+            ...(!lintPassed ? { outcome: 'lint-failed' } : {}),
+          });
+        } catch { /* observation is fail-soft */ }
+      }
     }
-    try {
-      observeGoalAuthor('goal-author', 'summary', {
-        authorRunId,
-        elapsedMs: Date.now() - authorStartedAt,
-        inputTokens: enhanceTokens.inputTokens,
-        outputTokens: enhanceTokens.outputTokens,
-        totalTokens: enhanceTokens.inputTokens === null || enhanceTokens.outputTokens === null
-          ? null : enhanceTokens.inputTokens + enhanceTokens.outputTokens,
-        goalChars: [...document].length,
-        sectionChars: authoredGoalSectionChars(document),
-      });
-    } catch { /* observation is fail-soft */ }
     return { document, facts, grounded: !groundingError && hasEvidence, authorRunId };
   } finally {
     endAssembleSubphase();

package/src/self-implement/goal-clarification-escalation.ts

@@ -11,9 +11,13 @@ import {
   writePendingQuestion,
 } from '../ask-user-question/pending-questions.js';
 import { debug } from '../debug/log.js';
+import { writeGoalDocumentAtomic } from './goal-document-write.js';
 import {
   applyClarificationReply,
   parseGoalDocumentClarifications,
+  selfAnswerGoalDocumentClarifications,
+  type GoalClarificationSelfResolver,
+  type GoalClarificationSelfAnswerPath,
 } from './goal-author-clarification.js';
 import type { HitlDelivery } from '../hitl/types.js';
 
@@ -49,6 +53,8 @@ export interface GoalClarificationEscalationInput {
   resolveOriginDelivery?: (sessionId: string) => HitlDelivery | undefined;
   /** Non-blocking terminal fallback for a non-TUI delivery with no installed resolver. */
   fallback?: (message: string) => void;
+  selfResolveClarification?: GoalClarificationSelfResolver;
+  selfAnswerPath?: GoalClarificationSelfAnswerPath;
   /** Fail-soft pending persistence for terminal fallbacks; injectable for focused tests. */
   pendingQuestionPersistence?: {
     create: typeof createPendingQuestion;
@@ -404,6 +410,7 @@ export async function escalateGoalDocumentClarifications(
   const dispatchDelivery = delivery ?? 'modal';
   const recordedDelivery = input.resolvedDelivery ?? dispatchDelivery;
   let answersWritten = 0;
+  let selfAnswered = 0;
   let questionIds: string[] = [];
   const observeEscalation = (event: GoalClarificationObservationEvent, data: Record<string, unknown>): void => {
     writeEscalationObservation(event, { ...data, deliverySource, answersWritten, questionIds });
@@ -430,6 +437,35 @@ export async function escalateGoalDocumentClarifications(
     return result;
   }
 
+  if (input.selfAnswerPath) {
+    try {
+      const resolution = await selfAnswerGoalDocumentClarifications(document, {
+        path: input.selfAnswerPath,
+        ask: document,
+        resolver: input.selfResolveClarification,
+      });
+      if (resolution.newlyAnswered > 0) {
+        writeGoalDocumentAtomic(input.goalFile, resolution.document);
+        answersWritten += resolution.newlyAnswered;
+        selfAnswered += resolution.newlyAnswered;
+        document = resolution.document;
+        clarifications = parseGoalDocumentClarifications(document);
+        unanswered = clarifications.filter((clarification) => !clarification.answered);
+        deliveryIds = mapClarificationDeliveryIds(clarifications);
+        questionIds = [...new Set(unanswered.map((clarification) => clarification.questionId))];
+      }
+      if (unanswered.length === 0) {
+        const result = { unanswered: 0, escalated: 0, delivery: recordedDelivery, outcome: 'skipped' as const, answeredBy: 'agent' as const };
+        observeEscalation(result.outcome, { goalFile: input.goalFile, ...result, reason: 'self-answered' });
+        return result;
+      }
+    } catch (error) {
+      debug.log(GOAL_CLARIFICATION_ESCALATION_CATEGORY, 'self-answer-failed', {
+        path: input.selfAnswerPath, reason: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
   const dispatch = input.dispatch ?? dispatchAskUserQuestion;
   const pendingQuestionPersistence = input.pendingQuestionPersistence ?? {
     create: createPendingQuestion,
@@ -444,7 +480,7 @@ export async function escalateGoalDocumentClarifications(
   // ⛔⭐⭐⭐ 여기서부터의 조기 반환·폴백은 이 «누적값»을 쓴다 — 'none' 을 하드코딩하면
   //  앞 배치가 답했는데 뒤 배치가 취소·실패했을 때 「아무도 안 답했다」는 «거짓»이 된다
   //  (무인 리뷰 R2 must-fix · 실측 형태: 관측이 거짓말한다).
-  const seenProvenance = { explicit: new Set<'human' | 'agent'>(), unmarkedAnswer: false };
+  const seenProvenance = { explicit: new Set<'human' | 'agent'>(selfAnswered > 0 ? ['agent' as const] : []), unmarkedAnswer: false };
   const aggregate = (): GoalClarificationAnsweredBy => {
     const { explicit, unmarkedAnswer } = seenProvenance;
     // ⭐ 표시 없는 답도 «한 출처»로 센다 — legacy 경로는 사람이다(레포 안 리졸버는 이제 전부 명시한다).

package/src/self-implement/goal-document-write.ts

@@ -0,0 +1,28 @@
+/** Atomic goal-document replacement for self-answered clarifications (POD-SELF-ANSWER). */
+import { chmodSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
+
+export interface GoalDocumentWriteIo {
+  writeFileSync: (path: string, data: string, options?: { mode?: number }) => void;
+  renameSync: (from: string, to: string) => void;
+  rmSync: (path: string, options: { force: boolean }) => void;
+  statSync: (path: string) => { mode: number };
+  chmodSync: (path: string, mode: number) => void;
+}
+
+const realIo: GoalDocumentWriteIo = { writeFileSync, renameSync, rmSync, statSync, chmodSync };
+
+/** Replace a goal document atomically (temp file next to it + rename) so a failed write never leaves a torn goal.
+ *  The existing file's permission bits are kept, so a 0600 goal stays 0600 after replacement. */
+export function writeGoalDocumentAtomic(path: string, document: string, io: GoalDocumentWriteIo = realIo): void {
+  let mode: number | undefined;
+  try { mode = io.statSync(path).mode & 0o777; } catch { mode = undefined; }
+  const temporary = `${path}.self-answer-${process.pid}-${Date.now()}.tmp`;
+  try {
+    io.writeFileSync(temporary, document, mode === undefined ? undefined : { mode });
+    if (mode !== undefined) io.chmodSync(temporary, mode);
+    io.renameSync(temporary, path);
+  } catch (error) {
+    try { io.rmSync(temporary, { force: true }); } catch { /* best effort */ }
+    throw error;
+  }
+}

package/src/self-implement/heal-intake.ts

@@ -68,6 +68,10 @@ function liveHealRuns(root: string): Set<string> {
 /** A test process must never start the real heal loop — it spawns external grounding (10-05 load 150 incident). */
 export async function startHealLoop(file: string, options: HealLoopOptions, env: NodeJS.ProcessEnv = process.env,
   run: StartHealLoop = async (graph, args) => (await import('../graph-runner/runner.js')).runGraph(graph, args)): Promise<unknown> {
+  if (env.ELANOUS_POD_NAME) {
+    debug.log('heal.intake', 'skipped-in-pod', { ref: options.input.failureEvent.ref });
+    return undefined;
+  }
   if (env.NODE_ENV === 'test' || env.ELANOUS_TEST_HOME) {
     debug.log('heal.intake', 'loop-start-skipped-test', { runId: options.runId });
     return undefined;

package/src/self-implement/heal-triage.ts

@@ -156,6 +156,50 @@ export interface HealTriageResult {
   readonly evidence: readonly string[];
 }
 
+/** 수리 한도를 다 쓴 런의 결함 셋. 힐 루프가 이 셋 중 하나만 고른다. */
+export type ReworkCapDefectClass = 'test-defect' | 'goal-defect' | 'code-defect';
+
+/** 분류 뒤 힐 루프가 고르는 다음 행동. */
+export type ReworkCapNextAction = 'harvest' | 'relaunch' | 'card';
+
+export interface ReworkCapHealInput {
+  /** 게이트가 이번 diff 가 들여온 실패 수. 없으면 0. */
+  readonly introduced?: readonly string[];
+  /** 마지막 리뷰 must-fix. 없으면 빈 목록. */
+  readonly mustFix?: readonly string[];
+  readonly summary?: string;
+}
+
+export interface ReworkCapHealDecision {
+  readonly defectClass: ReworkCapDefectClass;
+  readonly nextAction: ReworkCapNextAction;
+  readonly evidence: readonly string[];
+}
+
+const GOAL_DEFECT = /골|goal|acceptance|수용 기준|요구가 모순|스펙|경계:/i;
+
+/**
+ * 수리 한도 소진 런을 «시험 결함 · 골 결함 · 코드 결함» 중 하나로 가르고
+ * 수확·재발사·카드 중 하나를 고른다. 근거는 게이트 introduced 목록과 마지막 리뷰 지적이다.
+ * 도입 실패가 있으면 코드 결함(재발사). 리뷰가 골·수용 기준을 짚으면 골 결함(카드).
+ * 그 밖(리뷰만 있거나 근거가 비면)은 시험 결함(수확)이다.
+ */
+export function classifyReworkCapExhaustion(input: ReworkCapHealInput): ReworkCapHealDecision {
+  const introduced = (input.introduced ?? []).map((item) => item.trim()).filter(Boolean);
+  const mustFix = (input.mustFix ?? []).map((item) => item.trim()).filter(Boolean);
+  const evidence = [
+    ...introduced.map((item) => `gate introduced: ${item}`),
+    ...mustFix.map((item) => `review must-fix: ${item}`),
+  ];
+  if (introduced.length > 0) {
+    return { defectClass: 'code-defect', nextAction: 'relaunch', evidence };
+  }
+  if (mustFix.some((item) => GOAL_DEFECT.test(item)) || (input.summary ? GOAL_DEFECT.test(input.summary) : false)) {
+    return { defectClass: 'goal-defect', nextAction: 'card', evidence };
+  }
+  return { defectClass: 'test-defect', nextAction: 'harvest', evidence };
+}
+
 const UNTESTABLE_EXT = new Set(['.md', '.json', '.yaml', '.yml', '.txt']);
 const ENVIRONMENT_CLAIM = /할당량|자격|기판|quota|credential|substrate/i;
 

package/src/self-implement/host-regate.ts

@@ -30,6 +30,8 @@ export type HostRegateDeps = {
   acquire?: (repoRoot: string) => Promise<() => void>;
   log?: (event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => void;
   freezeRoot?: string;
+  /** Test seam for the operational freeze authority; production always uses the host root. */
+  prodFreezeRoot?: string;
   runExposeGate?: typeof runExposeGate;
   syncMergedChecklist?: typeof import('../release-loop/merged-pr-checklist.js').syncMergedPrChecklist;
 };
@@ -241,7 +243,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     // --match-head-commit pins the head. gh has no base pin, so the base was re-read just
     // above; the seconds between that read and the merge are checked after the fact below.
     if (input.verifyOnly) return result('passed');
-    const landing = admitLandingMerge({ prNumber: input.prNumber, headCommit: input.headCommit, repoRoot: input.repoRoot, ...(input.goalFile ? { goalFile: input.goalFile } : {}) }, deps.freezeRoot, {}, input.resumed ? undefined : { prNumber: input.prNumber, repoRoot: input.repoRoot, headCommit: input.headCommit });
+    const landing = admitLandingMerge({ prNumber: input.prNumber, headCommit: input.headCommit, repoRoot: input.repoRoot, ...(input.goalFile ? { goalFile: input.goalFile } : {}) }, deps.freezeRoot, {}, input.resumed ? undefined : { prNumber: input.prNumber, repoRoot: input.repoRoot, headCommit: input.headCommit }, { prodFreezeRoot: deps.prodFreezeRoot });
     if (landing.kind !== 'merge') {
       debug.log('harness.merge', 'frozen', { pr: input.prNumber, ...(landing.kind === 'held' ? { reason: landing.freeze.reason, until: landing.freeze.until } : { resumedElsewhere: true }) });
       return { passed: true, failures: [], os: process.platform, status: 'frozen' };