elanous 0.2.17 → 0.2.18

package/src/self-implement/prior-draft-findings.ts

@@ -2,7 +2,7 @@ import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { debug } from '../debug/log.js';
-import { parse as parsePrCommentMeta } from '../agent-substrate/pr-comment-meta.js';
+import { expandRecords, parse as parsePrCommentMeta } from '../agent-substrate/pr-comment-meta.js';
 
 export interface PriorDraftPr {
   number: number;
@@ -85,9 +85,10 @@ export async function collectPriorDraftFindings({
         continue;
       }
       const prActivity = Date.parse(pr.state.toUpperCase() === 'CLOSED' ? pr.closedAt ?? pr.createdAt : pr.createdAt);
+      const records = comments.flatMap((comment) => expandRecords(comment.body).map((body) => ({ ...comment, body })));
       // A PR bearing the current run's comment is this run's PR, not a predecessor.
-      if (comments.some((comment) => parsePrCommentMeta(comment.body)?.run === currentRunId)) continue;
-      const reviewers = comments.flatMap((comment) => {
+      if (records.some((comment) => parsePrCommentMeta(comment.body)?.run === currentRunId)) continue;
+      const reviewers = records.flatMap((comment) => {
         const meta = parsePrCommentMeta(comment.body);
         return meta?.role === 'reviewer' && meta.run && meta.round !== undefined
           ? [{ comment, meta }] : [];

package/src/skills/skill-feedback.ts

@@ -0,0 +1,76 @@
+import { appendFileSync, readFileSync } from 'node:fs';
+import { debug } from '../debug/log.js';
+
+export interface SkillRun {
+  skill: string;
+  runId: string;
+  outcome: 'success' | 'failure';
+  failureKind?: string;
+  userCorrected: boolean;
+  retries: number;
+  durationMs: number;
+  at: string;
+}
+
+export interface SkillFixProposal {
+  skill: string;
+  failureKind: string;
+  evidenceRunIds: string[];
+  suggestion: string;
+  expectedEffect: string;
+}
+
+/** Record one run at the caller-supplied ledger path; never touch a skill file. */
+export function appendSkillRun(ledgerPath: string, run: SkillRun): void {
+  appendFileSync(ledgerPath, `${JSON.stringify(run)}\n`, 'utf8');
+}
+
+/** Read the JSONL ledger in append order; an absent ledger has no runs. */
+export function readSkillRuns(ledgerPath: string): SkillRun[] {
+  let text: string;
+  try {
+    text = readFileSync(ledgerPath, 'utf8');
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return [];
+    throw error;
+  }
+  return text.split('\n').filter((line) => line.trim() !== '').map((line) => JSON.parse(line) as SkillRun);
+}
+
+/** Shadow-only suggestions for recurring failures within the same skill and failure kind. */
+export function proposeSkillFixes(
+  runs: readonly SkillRun[],
+  { threshold = 3 }: { threshold?: number } = {},
+): SkillFixProposal[] {
+  const grouped = new Map<string, Map<string, Map<string, SkillRun>>>();
+  for (const run of runs) {
+    if (run.outcome !== 'failure' || !run.failureKind) continue;
+    let kinds = grouped.get(run.skill);
+    if (!kinds) { kinds = new Map(); grouped.set(run.skill, kinds); }
+    let failures = kinds.get(run.failureKind);
+    if (!failures) { failures = new Map(); kinds.set(run.failureKind, failures); }
+    const previous = failures.get(run.runId);
+    if (!previous || run.at >= previous.at) failures.set(run.runId, run);
+  }
+
+  const proposals: SkillFixProposal[] = [];
+  for (const [skill, kinds] of grouped) {
+    for (const [failureKind, failures] of kinds) {
+      if (failures.size < threshold) continue;
+      const evidenceRunIds = [...failures.values()]
+        .map((run, index) => ({ run, index }))
+        .sort((a, b) => a.run.at.localeCompare(b.run.at) || a.index - b.index)
+        .slice(-3)
+        .map(({ run }) => run.runId);
+      proposals.push({
+        skill,
+        failureKind,
+        evidenceRunIds,
+        suggestion: `스킬 ${skill}의 ${failureKind} 실패 처리를 점검·개선하세요 — 같은 실패가 ${failures.size}번 반복됐습니다.`,
+        expectedEffect: `${skill}의 ${failureKind} 재발 감소`,
+      });
+      debug.log('skill.feedback', 'proposal', { skill, failureKind, runs: failures.size });
+    }
+  }
+  return proposals;
+}

package/src/task-agent/actions.ts

@@ -1,6 +1,17 @@
 export type NextActionKind = 'review' | 'land' | 'retry' | 'green' | 'decision';
+/**
+ * `retry` 의 갈래(RFC §A9 G1·G2). 없으면 종전 그대로 «must-fix 로 좁힌 재발사»다(must-fix 가 없으면 카드).
+ * - narrow: 범위를 좁혀 한 번 재발사(must-fix 없이도 간다 — no-progress)
+ * - wait: 기다렸다 재시도 — 실행부는 발사하지 않고 «대기 표지»만 남긴다(provider-exhausted · step-timeout)
+ * - salvage: 수확 가지에서 이어 발사(handed-off-to-salvage)
+ * - alternative: 같은 수 2회 실패 뒤 «다른 수»
+ */
+export type RetryVariant = 'narrow' | 'wait' | 'salvage' | 'alternative';
 export interface NextAction {
   kind: NextActionKind;
+  variant?: RetryVariant;
+  /** salvage 갈래에서 이어 받을 수확 가지(모르면 비운다). */
+  salvageBranch?: string;
   taskId: string;
   rationale: string;
   pr: number;
@@ -30,10 +41,21 @@ export interface ActionDeps {
   observe(event: 'task-agent.action', data: { taskId: string; kind: NextActionKind; result: string; reason: string }): void;
 }
 
+/** 실패 셈 키. 갈래가 있으면 갈래별로 센다(G2 — «다른 수»의 실패가 같은 칸에 쌓이지 않게). 없으면 종전 키 그대로. */
+export function failureKey(action: Pick<NextAction, 'taskId' | 'kind' | 'variant'>): string {
+  return JSON.stringify(action.variant ? [action.taskId, action.kind, action.variant] : [action.taskId, action.kind]);
+}
+
+const RETRY_HINT: Record<Exclude<RetryVariant, 'wait'>, (action: NextAction) => string> = {
+  narrow: action => `Narrow relaunch: previous run ${action.runId} made no progress. Halve the scope; keep the same acceptance line.`,
+  salvage: action => `Salvage relaunch: continue from the salvage branch ${action.salvageBranch ?? `of run ${action.runId}`} — take its diff, do not restart from scratch.`,
+  alternative: () => 'Alternative approach: the same move already failed twice. Choose a different approach than the previous runs.',
+};
+
 export async function executeNextAction(action: NextAction, deps: ActionDeps): Promise<string> {
   const record = (result: string, reason: string) => {
     if (result === 'failed' && (deps.failureCounts || deps.incrementFailure)) {
-      const key = JSON.stringify([action.taskId, action.kind]);
+      const key = failureKey(action);
       const next = deps.incrementFailure ? deps.incrementFailure(key) : (deps.failureCounts![key] ?? 0) + 1;
       if (deps.failureCounts) deps.failureCounts[key] = next;
       if (!deps.incrementFailure) deps.saveState?.();
@@ -41,14 +63,14 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     deps.observe('task-agent.action', { taskId: action.taskId, kind: action.kind, result, reason });
     return result;
   };
-  if (deps.mode !== 'live') return record('shadow', `would ${action.kind}: ${action.rationale}`);
+  if (deps.mode !== 'live') return record('shadow', `would ${action.kind}${action.variant ? `:${action.variant}` : ''}: ${action.rationale}`);
   const card = async (reason: string) => {
     const evidence = JSON.stringify({ runId: action.runId, pr: action.pr, mustFix: action.mustFix ?? [], history: action.history ?? [], selected: action.kind, reason });
     const result = await deps.command(['decisions', 'raise', '--title', `${action.taskId}: ${reason}`, '--category', action.risk === 'money' ? 'money' : action.risk === 'security' ? 'security' : action.risk === 'irreversible-publication' ? 'publish' : 'other', '--s', `Task ${action.taskId} needs a decision.`, '--c', reason, '--ref', evidence, '--q', 'Which action should be taken?', '--option', 'h=Keep on hold:no automatic execution', '--option', 'p=Approve action:execute after approval', '--skip-recommend', 'requires human decision', '--no-xcheck', 'automated escalation']);
     return record(result.status === 0 ? 'decision' : 'failed', reason);
   };
   if (action.risk) return card(`risk: ${action.risk}`);
-  if ((deps.failureCounts?.[JSON.stringify([action.taskId, action.kind])] ?? deps.failures ?? 0) >= 2) return card('same task/action failed twice');
+  if ((deps.failureCounts?.[failureKey(action)] ?? deps.failures ?? 0) >= 2) return card('same task/action failed twice');
   if (action.kind === 'land') {
     if (!action.cwd) return card('landing worktree unknown');
     const view = await deps.command(['gh', 'pr', 'view', String(action.pr), '--json', 'labels']);
@@ -66,7 +88,10 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
   }
   if (action.kind === 'decision') return card(action.rationale);
   if (action.kind === 'green') return card('green requires a verified landing in this execution');
-  if (action.kind === 'retry' && !action.mustFix?.length) return card('must-fix missing; cannot narrow retry');
+  // G1 — 기다림은 발사가 아니다: 대기 표지만 남기고 다음 틱이 다시 판단한다(카드로 올리지 않는다).
+  if (action.kind === 'retry' && action.variant === 'wait') return record('waiting', `wait marker: ${action.rationale}`);
+  // must-fix 없는 재발사가 카드로 가는 것은 갈래 없는(종전) retry 뿐이다 — narrow·salvage·alternative 는 갈래 문면으로 간다.
+  if (action.kind === 'retry' && !action.variant && !action.mustFix?.length) return card('must-fix missing; cannot narrow retry');
   if (action.kind === 'review') {
     const review = await deps.command(['self', 'review', String(action.pr), '--json']);
     if (review.status !== 0) return record('failed', 'review command failed');
@@ -83,8 +108,7 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
     return card('review verdict or must-fix unavailable');
   }
   // 여기 닿는 종류는 land · retry 둘뿐이다(green·decision·review 는 위에서 끝난다).
-  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!]
-    : ['harness', 'say', `${action.original}\n\nMust-fix:\n${(action.mustFix ?? []).join('\n')}\n\nPrevious run: ${action.runId}`];
+  const args = action.kind === 'land' ? ['pr', 'land', '--cwd', action.cwd!] : ['harness', 'say', retryText(action)];
   const day = deps.landingDay ?? new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
   const outcome = await deps.command(args);
   if (outcome.status !== 0) {
@@ -116,3 +140,12 @@ export async function executeNextAction(action: NextAction, deps: ActionDeps): P
   }
   return record('done', action.rationale);
 }
+
+/** 재발사 문면 — 원문은 고치지 않고 앞에 둔다 · 갈래 문면 · must-fix · 직전 런 순서. */
+export function retryText(action: NextAction): string {
+  const sections = [action.original];
+  if (action.variant && action.variant !== 'wait') sections.push(RETRY_HINT[action.variant](action));
+  if (action.mustFix?.length) sections.push(`Must-fix:\n${action.mustFix.join('\n')}`);
+  sections.push(`Previous run: ${action.runId}`);
+  return sections.join('\n\n');
+}

package/src/task-agent/judge.ts

@@ -5,7 +5,7 @@
  * 부작용이 없다(발사·리뷰·착지는 실행부 `actions.ts` 의 몫). 수확 원천 = run-c9ad6d6d `chooseTaskAction`.
  */
 import type { SupervisorStopReason } from '../self-dev/run-supervisor.js';
-import type { NextActionKind } from './actions.js';
+import type { NextActionKind, RetryVariant } from './actions.js';
 
 export type TaskMove =
   | 'propose-green'
@@ -35,6 +35,11 @@ export interface TaskJudgement {
   reason: string;
   /** 실행부(`executeNextAction`)가 바로 받는 수면 그 종류. 없으면 발사·대기 계열(실행부 밖). */
   executorKind?: NextActionKind;
+  /**
+   * 실행부 `retry` 의 갈래(§A9 G2). 좁혀 재발사 · 기다렸다 재시도 · 수확 이어 발사 · 다른 수가
+   * 같은 재발사로 접히지 않게 실행부에 넘긴다. retry 가 아닌 수에는 없다.
+   */
+  executorVariant?: RetryVariant;
 }
 
 /** 같은 수가 이 횟수만큼 실패하면 다른 수로 넘어간다(RFC §A2 «같은 수 2번 실패»). */
@@ -51,6 +56,13 @@ const EXECUTOR_KIND: Partial<Record<TaskMove, NextActionKind>> = {
   'decision-card': 'decision',
 };
 
+const EXECUTOR_VARIANT: Partial<Record<TaskMove, RetryVariant>> = {
+  'narrow-relaunch': 'narrow',
+  'wait-retry': 'wait',
+  'salvage-relaunch': 'salvage',
+  alternative: 'alternative',
+};
+
 function base(input: TaskJudgeInput): Omit<TaskJudgement, 'executorKind'> {
   const stop = input.stopReason;
   const merged = input.prState === 'MERGED' && input.pr !== undefined && input.pr !== '';
@@ -82,15 +94,29 @@ function base(input: TaskJudgeInput): Omit<TaskJudgement, 'executorKind'> {
   }
 }
 
-/** 종료 어휘·관측에서 다음 한 수를 고른다. 같은 수 2회 실패 → 다른 수 → 그것도 실패 → 결정 카드. */
+/** 재발사 계열 — 대안(alternative)이 실패한 «같은 실패 흐름»에 속하는 수. */
+const RETRY_FAMILY: ReadonlySet<TaskMove> = new Set<TaskMove>(['narrow-relaunch', 'wait-retry', 'salvage-relaunch']);
+
+/**
+ * 종료 어휘·관측에서 다음 한 수를 고른다. 같은 수 2회 실패 → 다른 수 → 그것도 실패 → 결정 카드.
+ *
+ * ⭐ 새 관측이 이긴다(사후 리뷰 must-fix · #24453): 병합된 PR(propose-green)·종료 미관측(wait)·표 밖 어휘(decision-card)는
+ * 실패 셈과 무관하게 그대로 간다. 「대안도 실패 → 결정 카드」 승격은 지금 수가 같은 실패 흐름일 때만 —
+ * 재발사 계열이거나, 그 수 자신이 이미 같은 수 한도만큼 실패했을 때다.
+ */
 export function judgeNextMove(input: TaskJudgeInput): TaskJudgement {
   const failures = input.failures ?? {};
   let judged = base(input);
-  if ((failures.alternative ?? 0) >= 1) {
+  const escalatable = judged.move !== 'wait' && judged.move !== 'decision-card' && judged.move !== 'propose-green';
+  const exhausted = escalatable && (failures[judged.move] ?? 0) >= SAME_MOVE_FAILURE_LIMIT;
+  const inFailingFlow = RETRY_FAMILY.has(judged.move) || exhausted;
+  if (escalatable && inFailingFlow && (failures.alternative ?? 0) >= 1) {
     judged = { move: 'decision-card', stage: 'escalated', reason: `대안도 실패 — 런·PR·must-fix 근거로 사람 결정 (직전: ${judged.move})` };
-  } else if (judged.move !== 'wait' && judged.move !== 'decision-card' && (failures[judged.move] ?? 0) >= SAME_MOVE_FAILURE_LIMIT) {
+  } else if (exhausted) {
     judged = { move: 'alternative', stage: 'repairing', reason: `같은 수 ${SAME_MOVE_FAILURE_LIMIT}회 실패 — 다른 수 선택 (${judged.move})` };
   }
   const executorKind = EXECUTOR_KIND[judged.move];
-  return executorKind ? { ...judged, executorKind } : judged;
+  const executorVariant = EXECUTOR_VARIANT[judged.move];
+  if (!executorKind) return judged;
+  return executorVariant ? { ...judged, executorKind, executorVariant } : { ...judged, executorKind };
 }