elanous 0.2.16 → 0.2.18

package/src/task-agent/actions.ts

@@ -0,0 +1,151 @@
+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;
+  runId: string;
+  original: string;
+  checklistId: string;
+  history?: string[];
+  mustFix?: string[];
+  cwd?: string;
+  risk?: 'money' | 'security' | 'irreversible-publication';
+}
+export interface ActionDeps {
+  command(args: string[]): Promise<{ status: number; stdout: string; stderr?: string }>;
+  mode?: string;
+  landingsToday?: number;
+  landingDay?: string;
+  saveState?(): void;
+  dailyLimit?: number;
+  failures?: number;
+  failureCounts?: Record<string, number>;
+  /** 하루 착지 칸을 잠금 안에서 먼저 확보한다 — 다른 프로세스와 같은 잔여 칸을 두 번 쓰지 않게. 없으면 메모리 셈. */
+  reserveLanding?(day: string, limit: number): boolean;
+  /** 병합이 확인되지 않으면 확보한 칸을 돌려준다. */
+  releaseLanding?(day: string): void;
+  /** 실패 한 번을 잠금 안에서 디스크에 더한다(다른 프로세스의 실패를 덮지 않게) · 더한 뒤의 값을 돌려준다. */
+  incrementFailure?(key: string): number;
+  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 = 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?.();
+    }
+    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.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?.[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']);
+    if (view.status !== 0) return card('PR labels unavailable');
+    let labels: unknown;
+    try { labels = (JSON.parse(view.stdout) as { labels?: unknown }).labels; }
+    catch { return card('PR labels unavailable'); }
+    if (!Array.isArray(labels) || !labels.every(label => label && typeof label === 'object' && typeof label.name === 'string')) return card('PR labels unavailable');
+    if (labels.some(label => label.name === 'elanous:release-path')) return card('release-path');
+    const day = new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
+    if (deps.landingDay && deps.landingDay !== day) deps.landingsToday = 0;
+    deps.landingDay = day;
+    const limit = deps.dailyLimit ?? 5;
+    if (deps.reserveLanding ? !deps.reserveLanding(day, limit) : (deps.landingsToday ?? 0) >= limit) return card('daily landing limit');
+  }
+  if (action.kind === 'decision') return card(action.rationale);
+  if (action.kind === 'green') return card('green requires a verified landing in this execution');
+  // 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');
+    let parsed: { verdict?: string; mustFix?: string[]; reviewed?: boolean };
+    try {
+      const payload: unknown = JSON.parse(review.stdout);
+      const item = Array.isArray(payload) ? payload.find((entry: unknown) => entry && typeof entry === 'object' && 'pr' in entry && Number(entry.pr) === action.pr) : payload;
+      if (!item || typeof item !== 'object' || Array.isArray(item)) return record('failed', 'invalid review JSON');
+      parsed = item as typeof parsed;
+    } catch { return record('failed', 'invalid review JSON'); }
+    if (parsed.reviewed !== true) return record('failed', 'review was not performed');
+    if (parsed.verdict === 'pass') { record('done', 'review pass'); return executeNextAction({ ...action, kind: 'land', history: [...(action.history ?? []), 'review pass'] }, deps); }
+    if (parsed.verdict === 'fail' && Array.isArray(parsed.mustFix) && parsed.mustFix.length > 0 && parsed.mustFix.every(fix => typeof fix === 'string' && fix.trim())) { record('done', 'review fail'); return executeNextAction({ ...action, kind: 'retry', mustFix: parsed.mustFix, history: [...(action.history ?? []), 'review fail'] }, deps); }
+    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', retryText(action)];
+  const day = deps.landingDay ?? new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' });
+  const outcome = await deps.command(args);
+  if (outcome.status !== 0) {
+    if (action.kind === 'land') deps.releaseLanding?.(day);
+    return record('failed', `${action.kind} command failed: ${outcome.stderr ?? ''}`);
+  }
+  if (action.kind === 'land') {
+    const merged = await deps.command(['gh', 'pr', 'view', String(action.pr), '--json', 'state,mergeCommit']);
+    let sha: string | undefined;
+    let notMerged = false;
+    try {
+      const value = JSON.parse(merged.stdout) as { state?: string; mergeCommit?: { oid?: string } };
+      if (merged.status === 0 && value.state === 'MERGED' && /^[a-f0-9]{40}$/i.test(value.mergeCommit?.oid ?? '')) sha = value.mergeCommit?.oid;
+      else if (merged.status === 0 && typeof value.state === 'string' && value.state !== 'MERGED') notMerged = true;
+    } catch { /* unknown merge state is never green */ }
+    if (!sha) {
+      // «열림»으로 확인됐을 때만 칸을 돌려준다. 상태를 못 읽었으면 병합됐을 수 있으니 칸은 쓴 것으로 둔다(상한을 넘지 않게).
+      if (notMerged) deps.releaseLanding?.(day);
+      return card('landing commit unknown; checklist remains unchanged');
+    }
+    record('done', action.rationale);
+    if (!deps.reserveLanding) deps.landingsToday = (deps.landingsToday ?? 0) + 1;
+    deps.saveState?.();
+    const green = await deps.command(['release', 'checklist', 'set', action.checklistId, '--status', 'green', '--evidence', `${action.pr}·${sha}`]);
+    // 체크리스트 실패는 이 과제·land 의 실패로 센다(두 번이면 다음엔 카드).
+    if (green.status !== 0) return record('failed', `green command failed: ${green.stderr ?? ''}`);
+    deps.observe('task-agent.action', { taskId: action.taskId, kind: 'green', result: 'done', reason: action.rationale });
+    return 'done';
+  }
+  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

@@ -0,0 +1,122 @@
+/**
+ * TASK-AGENT 판단부 — 슈퍼바이저 종료 어휘(+ PR·리뷰 관측) → «다음 한 수».
+ *
+ * RFC-task-agent-any-task-to-completion-2026-10-06 §A2 표를 순수 함수로 옮긴다.
+ * 부작용이 없다(발사·리뷰·착지는 실행부 `actions.ts` 의 몫). 수확 원천 = run-c9ad6d6d `chooseTaskAction`.
+ */
+import type { SupervisorStopReason } from '../self-dev/run-supervisor.js';
+import type { NextActionKind, RetryVariant } from './actions.js';
+
+export type TaskMove =
+  | 'propose-green'
+  | 'review'
+  | 'propose-land'
+  | 'narrow-relaunch'
+  | 'wait-retry'
+  | 'salvage-relaunch'
+  | 'alternative'
+  | 'decision-card'
+  | 'wait';
+
+export interface TaskJudgeInput {
+  stopReason?: SupervisorStopReason;
+  prState?: 'OPEN' | 'MERGED' | 'CLOSED';
+  pr?: string | number;
+  /** `self review --json` 판정. 관측 못 했으면 비운다(«통과»로 읽지 않는다). */
+  review?: 'pass' | 'fail';
+  mustFix?: readonly string[];
+  /** 수마다 누적 실패 수. */
+  failures?: Partial<Record<TaskMove, number>>;
+}
+
+export interface TaskJudgement {
+  move: TaskMove;
+  stage: 'observing' | 'closing' | 'reviewing' | 'repairing' | 'waiting' | 'escalated';
+  reason: string;
+  /** 실행부(`executeNextAction`)가 바로 받는 수면 그 종류. 없으면 발사·대기 계열(실행부 밖). */
+  executorKind?: NextActionKind;
+  /**
+   * 실행부 `retry` 의 갈래(§A9 G2). 좁혀 재발사 · 기다렸다 재시도 · 수확 이어 발사 · 다른 수가
+   * 같은 재발사로 접히지 않게 실행부에 넘긴다. retry 가 아닌 수에는 없다.
+   */
+  executorVariant?: RetryVariant;
+}
+
+/** 같은 수가 이 횟수만큼 실패하면 다른 수로 넘어간다(RFC §A2 «같은 수 2번 실패»). */
+export const SAME_MOVE_FAILURE_LIMIT = 2;
+
+const EXECUTOR_KIND: Partial<Record<TaskMove, NextActionKind>> = {
+  'propose-green': 'green',
+  review: 'review',
+  'propose-land': 'land',
+  'narrow-relaunch': 'retry',
+  'wait-retry': 'retry',
+  'salvage-relaunch': 'retry',
+  alternative: 'retry',
+  '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 !== '';
+  if (merged) {
+    return { move: 'propose-green', stage: 'closing', reason: `병합된 PR ${input.pr} 근거로 칸 green 제안` };
+  }
+  switch (stop) {
+    case 'harvestable-awaiting-human':
+    case 'needs-human':
+      if (input.review === 'pass') return { move: 'propose-land', stage: 'reviewing', reason: 'self review 통과 — 착지 제안' };
+      if (input.review === 'fail') {
+        return { move: 'narrow-relaunch', stage: 'repairing', reason: `must-fix 로 좁혀 재발사: ${(input.mustFix ?? []).join(' · ') || '(must-fix 비어 있음)'}` };
+      }
+      return { move: 'review', stage: 'reviewing', reason: '수확 가능 런 — self review 필요' };
+    case 'no-progress':
+    case 'decomposable-no-progress':
+      return { move: 'narrow-relaunch', stage: 'repairing', reason: `${stop} — 범위를 좁혀 한 번 재발사(판정선 유지)` };
+    case 'provider-exhausted':
+    case 'step-timeout':
+      return { move: 'wait-retry', stage: 'waiting', reason: `${stop} — 대기 후 재시도` };
+    case 'handed-off-to-salvage':
+      return { move: 'salvage-relaunch', stage: 'repairing', reason: '수확 브랜치 diff 를 가져와 이어 발사' };
+    case 'converged':
+      return { move: 'wait', stage: 'observing', reason: '완주했으나 PR 병합 근거 대기' };
+    case undefined:
+      return { move: 'wait', stage: 'observing', reason: '종료 관측 대기' };
+    default:
+      return { move: 'decision-card', stage: 'escalated', reason: `표에 없는 종료 어휘 ${stop} — 근거 붙여 사람 결정` };
+  }
+}
+
+/** 재발사 계열 — 대안(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);
+  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 (exhausted) {
+    judged = { move: 'alternative', stage: 'repairing', reason: `같은 수 ${SAME_MOVE_FAILURE_LIMIT}회 실패 — 다른 수 선택 (${judged.move})` };
+  }
+  const executorKind = EXECUTOR_KIND[judged.move];
+  const executorVariant = EXECUTOR_VARIANT[judged.move];
+  if (!executorKind) return judged;
+  return executorVariant ? { ...judged, executorKind, executorVariant } : { ...judged, executorKind };
+}