elanous 0.2.19 → 0.2.21

package/src/self-implement/blocked-draft-policy.ts

@@ -1,6 +1,107 @@
+import type { AbandonedClassification } from './abandoned-classification.js';
+
 /** Environment interruptions have a resumable branch, not a human draft decision. */
 export function blockedDraftDisposition(classification: string | undefined): 'open-draft' | 'preserve-branch' {
   return classification === 'provider-error' || classification === 'quota-exhausted' || classification === 'credential-failure'
     ? 'preserve-branch'
     : 'open-draft';
 }
+
+/**
+ * DRAFT-NOT-ARCHIVE (RFC-draft-pr-accumulation-root-fix R1 · 첫 조각)
+ *
+ * S: 멈춘 런은 산출을 draft PR 로 남겼다 — PR 이 «실패 보관소»가 되어 열린 PR 이 200 을 넘고 겹침 검사가 눈이 멀었다.
+ * C: 닫힌 147건 중 사람이 실제로 봐야 했던 것은 «주인 자리» 47건뿐이었다.
+ * Q: 어느 멈춤이 PR 을 열 자격이 있나?
+ * A: 사람 판단이 필요한 멈춤(needs-owner)만. 나머지(harvestable)는 수확 가지 `salvage/<run>/<leaf>` ⊕ 런 원장의 «사유 · 다음 수»로 남긴다.
+ *    `tools.selfImplement.draftOnStop` = 'always'(기본 · 종전) | 'needs-owner-only'.
+ */
+export type DraftOnStopMode = 'needs-owner-only' | 'always';
+export const DRAFT_ON_STOP_MODES = ['needs-owner-only', 'always'] as const satisfies readonly DraftOnStopMode[];
+export const DEFAULT_DRAFT_ON_STOP: DraftOnStopMode = 'always';
+
+/** landable = 승인된 산출(merge-approved-abandoned) — 다음 수가 `pr land` 이므로 수확 가지로 숨기지 않고 PR 로 남긴다(⛔ needs-owner 라벨은 안 단다). */
+export type StopClass = 'needs-owner' | 'harvestable' | 'landable';
+
+const LANDABLE: ReadonlySet<string> = new Set<AbandonedClassification>(['merge-approved-abandoned']);
+
+/** 사람(주인 자리)이 골·계약·처분을 정해야 풀리는 멈춤. 모르는 분류는 «needs-owner» 쪽으로 기운다(⛔ 산출을 PR 밖으로 숨기지 않는다). */
+const NEEDS_OWNER: ReadonlySet<string> = new Set<AbandonedClassification>([
+  'contract-conflict',
+  'goal-unconvergeable-candidate',
+  'pr-declined',
+]);
+
+const HARVESTABLE: ReadonlySet<string> = new Set<AbandonedClassification>([
+  'implementation-deficit',
+  'report-deficit',
+  'artifact-deficit',
+  'run-deadline-exceeded',
+  'already-satisfied',
+  'quota-exhausted',
+  'provider-error',
+  'credential-failure',
+]);
+
+export function stopClassFor(classification: string | undefined): StopClass {
+  if (classification && NEEDS_OWNER.has(classification)) return 'needs-owner';
+  if (classification && LANDABLE.has(classification)) return 'landable';
+  if (classification && HARVESTABLE.has(classification)) return 'harvestable';
+  return 'needs-owner';
+}
+
+const NEXT_MOVE: Record<string, string> = {
+  'implementation-deficit': '수확 가지에서 같은 골을 이어 돌린다(resume 1회) — 그래도 멈추면 needs-owner',
+  'report-deficit': '수확 가지에서 완료 증거·보고를 보강해 다시 게이트에 올린다',
+  'artifact-deficit': '수확 가지에서 요구 산출물을 채워 다시 돌린다',
+  'run-deadline-exceeded': '수확 가지에서 이어 돌리거나, 산출이 작으면 골을 쪼개 재발사한다',
+  'merge-approved-abandoned': '승인된 산출이다 — 이 PR 을 착지 경로(pr land)로 올린다',
+  'already-satisfied': '고칠 것이 없다 — 재발사하지 말고 카드를 닫는다',
+  'quota-exhausted': '용량 회복 뒤 수확 가지에서 이어 돌린다',
+  'provider-error': 'provider 복구 뒤 수확 가지에서 이어 돌린다',
+  'credential-failure': '인증 복구 뒤 수확 가지에서 이어 돌린다',
+  'contract-conflict': '주인 자리가 골의 상충 기준을 정정한다',
+  'goal-unconvergeable-candidate': '주인 자리가 되풀이된 must-fix 와 골 계약을 대조해 골을 다시 쓰거나 쪼갠다',
+  'pr-declined': '주인 자리가 거절 사유를 반영할지 골을 다시 정할지 정한다',
+};
+
+export function nextMoveFor(classification: string | undefined): string {
+  return (classification && NEXT_MOVE[classification]) ?? '주인 자리가 중단 사유를 읽고 처분을 정한다(분류 못 함)';
+}
+
+export type DraftOnStopDecision =
+  | { action: 'open-draft'; stopClass: StopClass; mode: DraftOnStopMode; ownerLabel?: string }
+  | { action: 'salvage-branch'; stopClass: 'harvestable'; mode: 'needs-owner-only' };
+
+/** 'always' 는 종전 그대로(라벨도 그대로). 'needs-owner-only' 는 harvestable → 수확 가지 · needs-owner·landable → draft ⊕ 주인 자리 라벨.
+ *  ⛔ 자리를 모르면 자리 라벨을 «안 단다»(OP 로 추측해 달면 «안다»고 말하는 셈이다) — `elanous:needs-owner` 만 남는다. */
+export function decideDraftOnStop(input: { mode: DraftOnStopMode; classification: string | undefined; seat?: string }): DraftOnStopDecision {
+  const stopClass = stopClassFor(input.classification);
+  if (input.mode !== 'needs-owner-only') return { action: 'open-draft', stopClass, mode: 'always' };
+  if (stopClass === 'harvestable') return { action: 'salvage-branch', stopClass, mode: 'needs-owner-only' };
+  const ownerLabel = ownerSeatLabel(input.seat);
+  return { action: 'open-draft', stopClass, mode: 'needs-owner-only', ...(ownerLabel ? { ownerLabel } : {}) };
+}
+
+const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
+
+/** 주인 자리 라벨 — `helper-repair` 가 읽는 `elanous:seat-<자리>` 꼴. 아는 자리일 때만 낸다(모르면 undefined). */
+export function ownerSeatLabel(seat: string | undefined): string | undefined {
+  const trimmed = seat?.trim().toUpperCase();
+  return trimmed && (SEATS as readonly string[]).includes(trimmed) ? `elanous:seat-${trimmed}` : undefined;
+}
+
+/** 런 하나의 수확 가지 — `salvage/run-<6hex>/<가지 잎>`. 잎이 `-r<6hex>` 로 끝나면 `selectRunSalvageRefs` 가 그대로 찾는다. */
+export function salvageBranchForRun(runId: string, branch: string): string {
+  // `salvage-branches.ts` `runSuffixKey` 와 같은 규칙 — 그 모듈은 실행 러너를 끌고 와 user-config 가 부를 수 없다.
+  const key = /^(?:run-)?([0-9a-f]{6})/i.exec(runId.trim())?.[1]?.toLowerCase();
+  const runShort = key ? `run-${key}` : (runId.replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24) || 'run-unknown');
+  const leaf = branch.replace(/[^A-Za-z0-9._-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '').replace(/\.\.+/g, '.').replace(/\.lock$/i, '-lock') || 'branch';
+  return `salvage/${runShort}/${leaf}`;
+}
+
+export function parseDraftOnStopMode(raw: unknown): { mode: DraftOnStopMode; invalid: boolean } {
+  if (raw === undefined) return { mode: DEFAULT_DRAFT_ON_STOP, invalid: false };
+  if (typeof raw === 'string' && (DRAFT_ON_STOP_MODES as readonly string[]).includes(raw)) return { mode: raw as DraftOnStopMode, invalid: false };
+  return { mode: DEFAULT_DRAFT_ON_STOP, invalid: true };
+}

package/src/self-implement/execution-clarification.ts

@@ -15,6 +15,10 @@ import { appendRunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
 
 export interface ExecutionClarificationContext {
   runId: string;
+  outsideFiles?: readonly string[];
+  /** Full outside count — when larger than `outsideFiles`, the card says how many names it does not show. */
+  outsideCount?: number;
+  declaredPaths?: readonly string[];
   budget?: ClarificationContext['budget'];
   pendingQuestionCount?: number;
   config?: { hitl?: { executionDeadlineMinutes?: number } };
@@ -71,6 +75,13 @@ export async function askAtExecution(
 
   const request = toAskUserQuestionRequest(decision);
   if (!request) throw new Error('Execution clarification policy approved a question without a valid wire request.');
+  if (candidate.id === 'execution_scope' && ctx.outsideFiles) {
+    const sibling = (file: string) => ctx.declaredPaths === undefined ? 'unknown'
+      : file.endsWith('.test.ts') && ctx.declaredPaths.includes(file.replace(/\.test\.ts$/, '.ts')) ? 'yes' : 'no';
+    const hidden = Math.max(0, (ctx.outsideCount ?? ctx.outsideFiles.length) - ctx.outsideFiles.length);
+    const details = `Run ID: ${ctx.runId}\nOutside files:\n${ctx.outsideFiles.map(file => `- ${file} (declared-path sibling test: ${sibling(file)})`).join('\n')}${hidden > 0 ? `\n- … ${hidden} more outside file(s) not shown — inspect the worktree diff before expanding scope` : ''}`;
+    for (const question of request.questions) question.question += `\n\n${details}`;
+  }
   const configured = ctx.config === undefined
     ? getUserConfig().hitl?.executionDeadlineMinutes
     : ctx.config.hitl?.executionDeadlineMinutes;

package/src/self-implement/frozen-merges.ts

@@ -4,6 +4,8 @@ import { createHash } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
+import { enterJourneyNode, exitJourneyNode, passJourneyNode, withJourneyNodeSync } from '../self-dev/graph-journey-nodes.js';
+import { routeJourneyEdge } from '../self-dev/graph-journey-route.js';
 import { beginLandingMerge, type LandingFreeze } from '../release-loop/landing-freeze.js';
 
 /** `manual`: the owning repository could not be determined — a sweep never resumes it; a person does. */
@@ -183,6 +185,26 @@ export function admitLandingMerge(
   hooks: { afterQueue?: () => void } = {},
   claimKey?: { prNumber: number; repoRoot: string; headCommit?: string },
   opts: { prodFreezeRoot?: string; forceReason?: string } = {},
+): LandingAdmission {
+  // HARNESS-FULL-GRAPH — 병합 직전 한 곳의 동결 검사가 그래프 노드 freeze-check(출구: open | frozen | taken)이고,
+  // 동결이면 보류 대기열이 노드 hold 다. 판정은 바꾸지 않는다 — 관측만.
+  const pr = claimKey?.prNumber;
+  enterJourneyNode('freeze-check', { provenance: 'admit-landing-merge', ...(pr === undefined ? {} : { data: { pr } }) });
+  const admission = withJourneyNodeSync('freeze-check', { provenance: 'admit-landing-merge', ...(pr === undefined ? {} : { data: { pr } }) },
+    () => admitLandingMergeUnobserved(heldEntry, root, hooks, claimKey, opts));
+  const freezeLabel = admission.kind === 'merge' ? 'open' : admission.kind === 'held' ? 'frozen' : 'taken';
+  exitJourneyNode('freeze-check', { provenance: 'admit-landing-merge', outcome: freezeLabel, ...(pr === undefined ? {} : { data: { pr } }) });
+  // 2판: 간선 판독을 남긴다(관측). 승인 요구(open→hold) 강제는 0.2.22 — 보류 사유 값이 먼저다(RFC §3).
+  routeJourneyEdge('freeze-check', freezeLabel, { freeze: freezeLabel });
+  return admission;
+}
+
+function admitLandingMergeUnobserved(
+  heldEntry: FrozenMerge | null | (() => FrozenMerge | null),
+  root: string,
+  hooks: { afterQueue?: () => void },
+  claimKey: { prNumber: number; repoRoot: string; headCommit?: string } | undefined,
+  opts: { prodFreezeRoot?: string; forceReason?: string },
 ): LandingAdmission {
   let entry: FrozenMerge | null | undefined;
   const prodFreezeRoot = opts.prodFreezeRoot ?? prodInstanceRoot();
@@ -223,6 +245,7 @@ export function admitLandingMerge(
     if (entry === undefined) entry = typeof heldEntry === 'function' ? heldEntry() : heldEntry; // only built when frozen
     if (!entry) return { kind: 'held', freeze: landing.frozen };
     queueFrozenMerge(entry, root);
+    passJourneyNode('hold', { provenance: 'admit-landing-merge', outcome: 'queued', data: { pr: entry.prNumber } });
     hooks.afterQueue?.();
     const afterQueue = beginLandingMerge(root, new Date(), prodFreezeRoot, opts.forceReason);
     if (afterQueue.frozen) return { kind: 'held', freeze: afterQueue.frozen };

package/src/self-implement/gate-env-retry.ts

@@ -0,0 +1,83 @@
+// ── GATE-ENV-RETRY (0.2.20 P1) — 환경 결손 gate 실패는 «게이트만» 다시 돈다 ─────────────
+//
+// S: 하니스 후반 gate 가 «환경 결손»(시험 결과 미수신 · git index.lock 경합 · tsc 힙 OOM ·
+//    「측정 불가」 · 네트워크/레지스트리 타임아웃)을 자식 실패와 같은 칸으로 받아,
+//    재작업 없이 `abandoned` 로 런을 끝냈다.
+// C: 📏 10-06 — TASK-AGENT 런 PR #24438 «test-result-unavailable · escalating without rework» ·
+//    NESTEDGUARD3 baseline index.lock 경합 · tsc 힙 OOM «could not measure».
+//    구현은 멀쩡한데 «잰 쪽»이 넘어졌고, 그 구현이 버려진 칸으로 셌다.
+// Q: 구현을 버리지 않고 잴 수 있나?
+// A: ⓐ 이 판정자가 «환경 결손»이라 말하면 짧게 쉬고 gate «만» 다시 돈다(기본 2회).
+//    ⓑ 그래도 결손이면 브랜치·PR 을 남기고 `harvestable` 로 끝낸다(「버림」이 아니라 「수확 대기」).
+//
+// ⛔ 틀리는 방향이 비대칭이다(`self-dev/execution-transient.ts` 와 같은 계산):
+//    도입 실패를 「환경」으로 부르면 → 자식 결손이 재작업 없이 수확 칸으로 빠진다.
+//    ⇒ `introduced > 0` 또는 자식 책임이 «있음»이면 무조건 거짓. 어휘는 좁게 둔다.
+// ⛔ `budget-exceeded`·`module-load-error` 는 넣지 않는다 — 다시 재도 같은 값이 나온다.
+
+/** 환경 결손의 종류 — 관측(로그)과 PR 문면에 그대로 실린다. */
+export type GateEnvDeficitKind =
+  | 'test-result-unavailable'
+  | 'infrastructure-failure'
+  | 'git-lock'
+  | 'out-of-memory'
+  | 'unmeasured'
+  | 'network-timeout';
+
+export type GateEnvDeficitVerdict =
+  | { readonly envDeficit: true; readonly kind: GateEnvDeficitKind }
+  | { readonly envDeficit: false; readonly reason: 'passed' | 'introduced' | 'child-responsible' | 'non-retryable-reason' | 'no-env-signal' };
+
+export interface GateEnvDeficitInput {
+  readonly passed: boolean;
+  readonly log?: string;
+  readonly reflectGateFacts?: {
+    readonly introduced?: number;
+    readonly unknownReason?: string;
+    readonly childResponsibility?: string;
+  };
+}
+
+/** unknownReason 중 «다시 재면 풀릴 수 있는» 것만. */
+const RETRYABLE_UNKNOWN_REASONS: ReadonlySet<string> = new Set(['test-result-unavailable', 'infrastructure-failure']);
+
+/** unknownReason 중 «다시 재도 같은 값이 나오는» 것 — 로그에 환경 어휘가 섞여 있어도 이 사유가 이긴다. */
+const NON_RETRYABLE_UNKNOWN_REASONS: ReadonlySet<string> = new Set(['budget-exceeded', 'module-load-error']);
+
+/** 로그 어휘 — ⛔ 좁게(위 비대칭). 순서가 곧 우선순위. */
+const LOG_PATTERNS: ReadonlyArray<readonly [GateEnvDeficitKind, RegExp]> = [
+  ['git-lock', /index\.lock|another git process seems to be running|cannot lock ref/i],
+  ['out-of-memory', /javascript heap out of memory|heap out of memory|oomkilled|fatal error: .*allocation failed/i],
+  ['unmeasured', /could not measure|측정 불가/i],
+  ['network-timeout', /\b(?:ETIMEDOUT|ECONNRESET|EAI_AGAIN|ENOTFOUND)\b|registry\.npmjs\.org.*(?:timeout|timed out)|network timeout|socket hang up/i],
+];
+
+/**
+ * 순수: 실패한 gate 결과가 «환경 결손»인가를 판정한다.
+ * ⛔ 도입 실패(`introduced > 0`)·자식 책임 있음은 언제나 거짓 — 그 동작은 바꾸지 않는다.
+ */
+export function classifyGateEnvDeficit(gate: GateEnvDeficitInput): GateEnvDeficitVerdict {
+  if (gate.passed) return { envDeficit: false, reason: 'passed' };
+  const facts = gate.reflectGateFacts;
+  if ((facts?.introduced ?? 0) > 0) return { envDeficit: false, reason: 'introduced' };
+  if (facts?.childResponsibility !== undefined && facts.childResponsibility !== 'none') {
+    return { envDeficit: false, reason: 'child-responsible' };
+  }
+  if (facts?.unknownReason !== undefined && NON_RETRYABLE_UNKNOWN_REASONS.has(facts.unknownReason)) {
+    return { envDeficit: false, reason: 'non-retryable-reason' };
+  }
+  if (facts?.unknownReason !== undefined && RETRYABLE_UNKNOWN_REASONS.has(facts.unknownReason)) {
+    return { envDeficit: true, kind: facts.unknownReason as GateEnvDeficitKind };
+  }
+  const log = gate.log ?? '';
+  for (const [kind, pattern] of LOG_PATTERNS) {
+    if (pattern.test(log)) return { envDeficit: true, kind };
+  }
+  return { envDeficit: false, reason: 'no-env-signal' };
+}
+
+/** 기본 재시도 정책 — 짧게 쉬고 gate 만 최대 2회. */
+export const DEFAULT_GATE_ENV_RETRY = { attempts: 2, delayMs: 20_000 } as const;
+
+/** 수확 대기로 남길 때 PR·종료 사유에 싣는 표지. */
+export const GATE_ENV_DEFICIT_HARVESTABLE_MARK = 'env-deficit, harvestable';

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

@@ -1363,6 +1363,20 @@ export function tracedPathReferences(document: string): TracedPathReference[] {
   return references;
 }
 
+/**
+ * AUTO-TARGET (10-08 canary · TSC-HEAP run-446cdc71): an authored goal whose `## PROBLEM` Situation line says
+ * NOT-GROUNDED has no persistent (Read-verified) evidence — `scqaNarrative` writes NOT-GROUNDED exactly when that
+ * channel is empty, and `## TRACED PATHS` then carries no path. Such a goal is a scope card, not an implementation
+ * goal: any target path it carries was not verified by grounding. Callers that know a path was machine-suggested
+ * (not written by the human) must not launch on it. Lite goals have no Situation line and return false.
+ */
+export function isNotGroundedWithoutPersistentEvidence(document: string): boolean {
+  const problem = markdownSection(document, 'PROBLEM');
+  if (problem === null) return false;
+  const situation = problem.split(/\r?\n/).find((line) => line.startsWith('Situation: '));
+  return situation !== undefined && situation.startsWith('Situation: NOT-GROUNDED') && tracedPathReferences(document).length === 0;
+}
+
 /** Inspect supplied goal text and branch name, optionally validating traced paths through an injected reader. */
 /**
  * Lint findings plus the number of inline invariant markers recognized for judgment candidates.

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

@@ -3,6 +3,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmdir
 import { dirname, join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
+import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { getUserConfig } from '../user-config.js';
 import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
 
@@ -184,6 +185,8 @@ export function recordFailureEvent(event: FailureEvent, root = effectiveInstance
     return false;
   });
   debug.log('heal.intake', 'recorded', { source: event.source, kind: event.kind, ref: event.ref, folded });
+  // HARNESS-FULL-GRAPH — 하니스 런 실패 사건의 접수가 그래프 노드 heal 이다(출구: started | folded).
+  if (event.source === 'harness-run') passJourneyNode('heal', { provenance: 'heal-intake', outcome: folded ? 'folded' : 'started', data: { kind: event.kind, ref: event.ref } });
   if (!folded) {
     const runId = healRunId(event);
     void Promise.resolve().then(() => startLoop(HEAL_GRAPH, { runId, input: { failureEvent: event }, deps: { root } }))