elanous 0.2.24 → 0.2.27

package/src/graph-wizard/generate.ts

@@ -52,6 +52,8 @@ export interface GraphWizardResult {
   recipes?: string;
   /** 실행 가능성 증명: 그 recipes 로 `graph run --dry-run` 을 걸어 본 결과. 하니스만. */
   dryRun?: { status: string; path: string[] };
+  /** 검증을 통과했지만 곁들인 경고(생성 실패 아님) — 예: «smell: linear-chain» 과 칸 내리기·유닛 끼우기 제안. */
+  warnings?: string[];
 }
 
 export interface GraphWizardDeps {
@@ -303,6 +305,74 @@ export function validateWizardYaml(kind: GraphKind, yaml: string): string[] {
   return issues;
 }
 
+/** 그래프 값어치 신호(RFC SW-GRAPH-SMELL · G1~G7) — 기계로 셀 수 있는 넷만 센다. */
+export interface GraphSignals {
+  /** G1 검증 노드 = kind judge|gate 비종단 노드의 결과 map 이 둘 이상으로 갈림 · G2 되돌림 루프 = 뒤로 가는 간선(이미 지난 노드로) ⊕ 그 노드 max_visits ≥ 2 · G3 승인 지점 = kind hitl 노드 · G4 갈래 = 비종단 노드의 결과 map 이 종단 아닌 서로 다른 둘 이상으로 갈림 */
+  counted: { G1: number; G2: number; G3: number; G4: number };
+  /** 못 셈 표시 — G5(재개)·G6(병렬)·G7(해상도). 0 으로 지어내지 않는다. */
+  notCounted: readonly ['G5', 'G6', 'G7'];
+  /** counted 넷의 합 — 둘 이상이면 그래프 값어치가 있다. */
+  total: number;
+}
+
+const GRAPH_SIGNALS_NOT_COUNTED = ['G5', 'G6', 'G7'] as const;
+
+/** 순수 함수 — YAML 텍스트만 받아 센다(LLM·파일·실행 0). 못 세는 신호는 0 으로 지어내지 않고 «못 셈»으로 둔다. */
+export function graphSignals(yaml: string): GraphSignals {
+  const counted = { G1: 0, G2: 0, G3: 0, G4: 0 };
+  const none = (): GraphSignals => ({ counted, notCounted: GRAPH_SIGNALS_NOT_COUNTED, total: 0 });
+  let doc: {
+    entry_node?: unknown; terminal_nodes?: unknown;
+    nodes?: Array<{ node_id?: unknown; kind?: unknown; max_visits?: unknown }>;
+    edges?: Array<{ from?: unknown; to?: unknown; map?: unknown }>;
+  } | null;
+  try { doc = parseYaml(yaml) as typeof doc; } catch { return none(); }
+  if (!doc) return none();
+  const nodes = (Array.isArray(doc.nodes) ? doc.nodes : []).filter((n) => n != null && typeof n.node_id === 'string');
+  const ids = new Set(nodes.map((n) => n.node_id as string));
+  const kindOf = new Map(nodes.map((n) => [n.node_id as string, typeof n.kind === 'string' ? n.kind : '']));
+  const visitsOf = new Map(nodes.map((n) => [n.node_id as string, Number(n.max_visits) || 0]));
+  const terminals = new Set((Array.isArray(doc.terminal_nodes) ? doc.terminal_nodes : []).map((t) => String(t)));
+  const targetsOf = new Map<string, Set<string>>();
+  for (const edge of Array.isArray(doc.edges) ? doc.edges : []) {
+    if (edge == null || typeof edge.from !== 'string' || !ids.has(edge.from)) continue;
+    const tos = typeof edge.to === 'string' ? [edge.to]
+      : edge.map && typeof edge.map === 'object'
+        ? Object.values(edge.map as Record<string, unknown>).filter((to): to is string => typeof to === 'string') : [];
+    const targets = targetsOf.get(edge.from) ?? new Set<string>();
+    for (const to of tos) if (ids.has(to)) targets.add(to);
+    if (targets.size > 0) targetsOf.set(edge.from, targets);
+  }
+  const entry = typeof doc.entry_node === 'string' && ids.has(doc.entry_node) ? doc.entry_node : undefined;
+  /** entry 에서 avoid 노드를 거치지 않고 닿는 노드들 = «이미 지난 노드»(avoid = 되돌림 간선의 출발 노드). entry 자신도 지난 노드로 센다. */
+  const passedBefore = (avoid?: string): ReadonlySet<string> => {
+    if (!entry) return new Set<string>();
+    const visited = new Set<string>([entry]);
+    const queue = [entry];
+    while (queue.length > 0) {
+      const current = queue.shift()!;
+      if (current === avoid) continue;
+      for (const to of targetsOf.get(current) ?? []) if (!visited.has(to)) { visited.add(to); queue.push(to); }
+    }
+    return visited;
+  };
+  for (const node of nodes) {
+    const id = node.node_id as string;
+    const targets = targetsOf.get(id) ?? new Set<string>();
+    if (kindOf.get(id) === 'hitl') counted.G3 += 1;
+    if (terminals.has(id)) continue;
+    if ((kindOf.get(id) === 'judge' || kindOf.get(id) === 'gate') && targets.size >= 2) counted.G1 += 1;
+    if ([...targets].filter((to) => !terminals.has(to)).length >= 2) counted.G4 += 1;
+  }
+  for (const [from, targets] of targetsOf) {
+    for (const to of targets) {
+      if (terminals.has(to) || (visitsOf.get(to) ?? 0) < 2) continue;
+      if (to === from ? passedBefore().has(from) : passedBefore(from).has(to)) counted.G2 += 1;
+    }
+  }
+  return { counted, notCounted: GRAPH_SIGNALS_NOT_COUNTED, total: counted.G1 + counted.G2 + counted.G3 + counted.G4 };
+}
+
 /** 노드 줄 끝 주석 `# 이름 | 단계 | 인자` 를 읽는다. 흐름식 노드 줄에서만. */
 export function parseNodeAnnotations(yaml: string): Record<string, WizardNodeStep> {
   const out: Record<string, WizardNodeStep> = {};
@@ -562,11 +632,17 @@ export async function generateGraphFromPrompt(req: GraphWizardRequest, deps: Gra
   }
   attempts = Math.min(attempts, maxAttempts);
   const ok = issues.length === 0;
+  // «선형 사슬» 냄새(SW-GRAPH-SMELL) — 경고만, 생성 실패가 아니다. 값어치 신호가 둘 이하면 칸 내리기·유닛 끼우기를 제안한다.
+  const warnings: string[] = [];
+  if (kind === 'harness' && ok) {
+    const signals = graphSignals(yaml);
+    if (signals.total <= 1) warnings.push(`smell: linear-chain — G 신호 ${signals.total} · 칸 내리기(스킬 사슬) 또는 유닛 끼우기(unit-verify = G1·G2 · 승인 노드 = G3) 제안`);
+  }
   const counted = summarizeChange(kind, editing ? req.currentYaml : undefined, yaml);
   const summary = llmSummary ? `${llmSummary} (${counted})` : counted;
   debug.log('graph.wizard', ok ? 'validated' : 'failed', { id, kind, base, attempts, editing, issues: issues.slice(0, 10), summary, dryRun: dryRun?.status, ms: Date.now() - startedAt });
   const labels = Object.fromEntries(Object.entries(steps).filter(([, v]) => v.label).map(([k, v]) => [k, v.label!]));
-  return { ok, id, yaml, ...(base ? { base } : {}), ...(base && baseReason ? { baseReason } : {}), issues, attempts, summary, labels, steps, ...(recipes ? { recipes } : {}), ...(dryRun ? { dryRun } : {}) };
+  return { ok, id, yaml, ...(base ? { base } : {}), ...(base && baseReason ? { baseReason } : {}), issues, attempts, summary, labels, steps, ...(recipes ? { recipes } : {}), ...(dryRun ? { dryRun } : {}), ...(warnings.length ? { warnings } : {}) };
 }
 
 /** v1 이름 유지 — 생성 YAML 의 노드 주석(단계·인자)으로 실제 recipes.yaml 을 낸다(v1 의 «미구현» 자리표시를 대체). */

package/src/grok.ts

@@ -14,7 +14,8 @@
 import type { GrokAnalysis, DiffResult, EnvDelta } from './types.js';
 import * as ui from './ui.js';
 import { getUserConfig } from './user-config.js';
-import { getProviderForConfig, anyProviderAvailable, textOnly, type LLMMessage } from './llm.js';
+import { getProviderForConfig, anyProviderAvailable, logAgentTurnUsage, type LLMMessage } from './llm.js';
+import type { LLMUsage } from './prompt-cache/types.js';
 
 /** True when any provider (env OR user-config, including Codex OAuth)
  *  can answer. Thin wrapper around llm.anyProviderAvailable() kept
@@ -34,19 +35,24 @@ async function callAnalyzer(prompt: string, systemPrompt?: string): Promise<stri
   if (systemPrompt) messages.push({ role: 'system', content: systemPrompt });
   messages.push({ role: 'user', content: prompt });
 
-  const events = provider.streamChat
-    ? provider.streamChat(messages, { temperature: 0.1, maxTokens: 1024 })
-    : null;
+  const llmOpts = { temperature: 0.1, maxTokens: 1024 };
   let text = '';
-  if (events) {
-    for await (const delta of textOnly(events)) text += delta;
+  let usage: LLMUsage = {};
+  if (provider.streamChat) {
+    for await (const ev of provider.streamChat(messages, llmOpts)) {
+      if (ev.type === 'text' && ev.delta) text += ev.delta;
+      else if (ev.type === 'usage') usage = { ...usage, ...ev.usage };
+    }
   } else {
     // Fallback to text-only chat (shouldn't happen — every provider
     // ships streamChat now).
-    for await (const chunk of provider.chat(messages, { temperature: 0.1, maxTokens: 1024 })) {
+    for await (const chunk of provider.chat(messages, llmOpts)) {
       text += chunk;
     }
   }
+  try {
+    logAgentTurnUsage(provider.defaultModel, usage, { providerName: provider.name, site: 'grok.direct' });
+  } catch { /* best-effort observation */ }
   return text;
 }
 

package/src/harness/harness-cli-command.ts

@@ -19,11 +19,14 @@ import { Command, Option } from 'commander';
 import { runGitCommand } from '../git-fs/runner.js';
 import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, resolveGoalAuthorGrade, tracedPathReferences, type GoalAuthorGrade, type GoalAuthorGradeSelection, type GoalType } from '../self-implement/goal-author.js';
 import { templateForGoalType } from '../self-implement/graph-templates.js';
-import { listRunLedgers, loadFederatedRunLedger, loadRunLedger, queryRunScreenKey, runLedgerDir, type RunLedgerMatch } from '../self-implement/run-ledger.js';
+import { appendRunLedgerEntry, listRunLedgers, loadFederatedRunLedger, loadRunLedger, queryRunScreenKey, runLedgerDir, type RunLedgerEntry, type RunLedgerMatch, type RunLedgerWriter } from '../self-implement/run-ledger.js';
+import { classifyPodExit, type PodExitClass } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 import { classifyPodExitStop, recordRunStop, runStopRecorded, RUN_STOP_EVENT } from '../self-implement/run-stop.js';
 import { ensureOpenRouterChildModelLive, resolveChildLlmEffort, resolveImplementationChildModel } from '../self-dev/dev-cli.js';
 import { resolveHarnessTarget } from '../self-implement/harness-target-options.js';
-import { buildRunProgressRows, queryRunningRuns, renderRunProgressTable } from '../self-implement/running-runs.js';
+import { buildRunProgressRows, isPartialRunningRuns, queryRunningRuns, renderRunProgressTable } from '../self-implement/running-runs.js';
+import { launchBindingRunIds, readLaunchBinding } from './launch-registry.js';
+import { psProcessStartMs } from './harness-stop.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
 import { collectDraftMetrics, collectOverlapMetrics, DRAFT_SWEEP_CONCURRENCY, mapBounded, resolveDraftSweepCloseCap, runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type OverlapMetricAdapters, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.js';
 import { readAskPreflightRowsSince, readSalvagedRowsSince } from '../self-dev/ask-launch-io.js';
@@ -34,11 +37,10 @@ import { debug } from '../debug/log.js';
 import { installHarnessSalvageCommand, installHarnessSalvageRetentionCommand } from './harness-salvage-cli.js';
 import { decideNestedElanousLaunch, readNestedElanousDepth } from './nested-elanous-policy.js';
 import { dispatchTask, type DispatchTaskInput, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
-import { launchRequestId, preLaunchGate, type PreLaunchGateDeps } from '../execution-loop/launch-gate.js';
+import { harnessLaunchBudgetDecision, launchRequestId, preLaunchGate, resolveLaunchBudget, type PreLaunchGateDeps } from '../execution-loop/launch-gate.js';
 import { PR_LABELS } from '../github/pr-labels.js';
 import { ghAutomationEnv } from '../autopilot/pr-manager.js';
-import { CODEX_PROVIDER, GROK_PROVIDER, decideBudget, decideLaunchBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
-import { DEFAULT_FALLBACK_CHAIN } from '../oauth/fallback-chain.js';
+import { decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
 import { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDeps } from './deliverable-verify-cli.js';
 import { getUserConfig } from '../user-config.js';
 import type { SiblingResyncAdapters, SiblingResyncResult, SiblingRunTarget } from '../self-implement/sibling-resync.js';
@@ -701,7 +703,7 @@ async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-s
     const classified = classifyHarnessPodExit({ status }, output, { ...(runId ? { runId } : {}) });
     recordClassifiedHarnessPodExit(runId ?? harnessPodRunId(output), classified.reason, status,
       { entrance, seat: o.seat, output });
-    recordHarnessPodStop(runId ?? harnessPodRunId(output), status, classified);
+    recordHarnessPodStop(runId ?? harnessPodRunId(output), status, classified, output);
     for (const line of classified.lines) console.error(line);
     process.exitCode = status;
   }
@@ -716,25 +718,62 @@ export function recordHarnessPodStop(
   runId: string | undefined,
   status: number,
   classified: { reason: string; lines: string[] },
-  deps: { loadLedger?: typeof loadRunLedger; record?: typeof recordRunStop } = {},
+  output?: string,
+  deps: { loadLedger?: typeof loadRunLedger; record?: typeof recordRunStop; write?: RunLedgerWriter } = {},
 ): boolean {
   if (!runId) return false;
   try {
     if (runStopRecorded(runId)) return false;
     if ((deps.loadLedger ?? loadRunLedger)(runId)?.some((entry) => entry.event === RUN_STOP_EVENT)) return false;
+    const nextMove = classified.reason === 'no-launch' ? 'Check Pod launch gate and pool, then relaunch'
+      : 'Inspect Pod exit classification and harvest the branch before relaunch';
+    const evidenceRef = `logs:harness.pod/exit-classified:${runId}`;
+    // AUT-POD-EXIT-UNCLASSIFIED ⓑ — only an unclassified exit reads the child output; classified reasons stay byte-identical.
+    const detail = classified.reason === 'unknown' ? podExitDetail(runId, status, output) : undefined;
+    if (detail) {
+      const write = deps.write ?? ((entry: RunLedgerEntry) => appendRunLedgerEntry(entry));
+      (deps.record ?? recordRunStop)({
+        runId, site: 'pod-exit', class: classifyPodExitStop(classified.reason),
+        cause: `Pod exit ${status}: ${detail.podExitClass}${detail.lead ? ` — ${detail.lead}` : ''}`,
+        evidenceRef, nextMove,
+      }, (entry) => write({ ...entry, data: { ...entry.data, podExitClass: detail.podExitClass, tail: detail.tail } }));
+      return true;
+    }
     // The classified line is our own one-line verdict («Pod 안 자식이 실패했다 — OOMKilled»), not the raw output tail.
     const verdict = classified.lines[0]?.split(' — ').slice(1).join(' — ').trim();
     (deps.record ?? recordRunStop)({
       runId, site: 'pod-exit', class: classifyPodExitStop(classified.reason),
       cause: `Pod exit ${status}: ${classified.reason}${verdict ? ` — ${verdict}` : ''}`,
-      evidenceRef: `logs:harness.pod/exit-classified:${runId}`,
-      nextMove: classified.reason === 'no-launch' ? 'Check Pod launch gate and pool, then relaunch'
-        : 'Inspect Pod exit classification and harvest the branch before relaunch',
-    });
+      evidenceRef, nextMove,
+    }, ...(deps.write ? [deps.write] : []));
     return true;
   } catch { return false; /* ledger observation cannot change Pod output or exit */ }
 }
 
+const POD_EXIT_TAIL_LINES = 5;
+const POD_EXIT_TAIL_LINE_CHARS = 240;
+const POD_EXIT_CAUSE_LEAD_CHARS = 160;
+
+/**
+ * The closed Pod exit class ⊕ the last meaningful output lines for an exit the host could not classify.
+ * Empty output is no evidence at all — `unknown` with an empty tail, never a guess. Fail-soft: a throw reads as `unknown`.
+ */
+function podExitDetail(runId: string, status: number, output: string | undefined): { podExitClass: PodExitClass; tail: string[]; lead: string } {
+  let podExitClass: PodExitClass = 'unknown';
+  let tail: string[] = [];
+  if (output?.trim()) {
+    try {
+      const exit = classifyPodExit({ logs: output, containerExitCode: status });
+      podExitClass = exit.class;
+      tail = exit.tail.slice(-POD_EXIT_TAIL_LINES).map((line) => Array.from(line).slice(0, POD_EXIT_TAIL_LINE_CHARS).join(''));
+    } catch { podExitClass = 'unknown'; tail = []; }
+  }
+  // The last meaningful line is where the child died (`Error: ENOSPC …`) — earlier tail lines are context.
+  const lead = Array.from(tail.at(-1) ?? '').slice(0, POD_EXIT_CAUSE_LEAD_CHARS).join('');
+  try { debug.log('harness.pod', 'exit-classified-detail', { runId, podExitClass, tailLines: tail.length }); } catch { /* observation is fail-soft */ }
+  return { podExitClass, tail, lead };
+}
+
 /**
  * POD-ANTHROPIC-PROVIDER ⓓ — 발사 관문과 Pod 가 «한 목록»(`POD_CHILD_PROVIDERS`)을 본다.
  * 🩸 10-10: 관문은 anthropic 을 «예산 판정 밖» 으로 통과시켰고 Pod 단계가 rc=2 로 죽었다(관문·Pod 목록 엇갈림).
@@ -754,39 +793,7 @@ function refusePodChildProviderBeforeLaunch(resolved: ResolvedHarnessSubstrate,
   return true;
 }
 
-const LAUNCH_BUDGET_PROVIDER: Readonly<Record<string, string>> = { 'codex-rotate': CODEX_PROVIDER, grok: GROK_PROVIDER };
-
-/**
- * L6 발사 관문의 예산 입력 보정 — 발사 우주의 config 에 체인이 없으면(작업 트리 = 시험 우주) 막지 않고
- * 코드 기본 체인으로 판단한다. `--child-llm-provider` 를 명시했으면 그것이 체인이다(예산 판정 밖 provider 는 통과).
- */
-export function harnessLaunchBudgetDecision(
-  inputs: BudgetInputs,
-  opts: { readonly childLlmProvider?: string; readonly childLlmModel?: string } = {},
-): { readonly decision: BudgetDecision; readonly warning?: string; readonly unmeasuredProvider?: string } {
-  const explicit = opts.childLlmProvider?.trim();
-  const judged = (selected: BudgetInputs) => {
-    const { decision, unmeasuredProvider } = decideLaunchBudget(selected);
-    return { decision, ...(unmeasuredProvider ? { unmeasuredProvider, warning: `budget: ${unmeasuredProvider} usage unmeasured — launching` } : {}) };
-  };
-  if (explicit) {
-    if (explicit !== CODEX_PROVIDER && explicit !== GROK_PROVIDER) {
-      return {
-        decision: { action: 'proceed', provider: explicit, ...(opts.childLlmModel ? { model: opts.childLlmModel } : {}), reasons: [`${explicit}: 명시 provider — 예산 판정 밖`] },
-        warning: `budget: ${explicit} is outside the budget gate — launched as requested`,
-      };
-    }
-    const chain = [{ provider: explicit, ...(opts.childLlmModel ? { model: opts.childLlmModel } : {}) }];
-    return judged({ ...inputs, preference: { ...inputs.preference, chain } });
-  }
-  if (inputs.preference.chain.length > 0) return judged(inputs);
-  const chain = DEFAULT_FALLBACK_CHAIN.map((step) => ({ provider: LAUNCH_BUDGET_PROVIDER[step] ?? step }));
-  const result = judged({ ...inputs, preference: { ...inputs.preference, chain } });
-  return {
-    ...result,
-    warning: `budget: no chain in this universe's config — judged with the code default ${DEFAULT_FALLBACK_CHAIN.join(',')}${result.warning ? ` · ${result.warning}` : ''}`,
-  };
-}
+export { harnessLaunchBudgetDecision } from '../execution-loop/launch-gate.js';
 
 async function readHarnessLaunchBudget(
   opts: { readonly childLlmProvider?: string; readonly childLlmModel?: string } = {},
@@ -1036,8 +1043,12 @@ async function dispatchHarnessAskSay(
     }
     enterJourneyNode('launch-gate', journey);
     const decision = await withJourneyNode('launch-gate', journey, async () => {
-      const budget = await (gate.readBudget ?? (() => readHarnessLaunchBudget(opts)))();
-      return preLaunchGate({ goalId, budget, forceLaunch: opts.forceGate === true }, gate);
+      const { budget, budgetSource, snapshotAgeSec } = await resolveLaunchBudget({
+        provider: opts.childLlmProvider,
+        measureLocal: gate.readBudget ?? (() => readHarnessLaunchBudget(opts)),
+        env: gate.readBudget ? { ELANOUS_SUBSTRATE: 'local' } : process.env,   // an injected budget reader is a host measurement, whatever substrate runs the test
+      });
+      return preLaunchGate({ goalId, budget, budgetSource, ...(snapshotAgeSec !== undefined ? { snapshotAgeSec } : {}), forceLaunch: opts.forceGate === true }, gate);
     });
     exitJourneyNode('launch-gate', { ...journey, outcome: decision.action === 'proceed' ? 'pass' : 'refuse', data: { action: decision.action } });
     if (decision.action !== 'proceed') {
@@ -2382,6 +2393,7 @@ const defaultDraftSweepStopRun: DraftSweepStopRun = async (runId) => {
 export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: DraftSweepGitExecute = runGitCommand, cwd = process.cwd(),
   executeAsync: (args: string[]) => Promise<string> = execute === executeGh ? executeGhAsync : async (args) => execute(args),
   stopRun: DraftSweepStopRun = defaultDraftSweepStopRun): GithubDraftSweepAdapters {
+  const ensuredSweepLabels = new Set<string>();
   const inventory = async (repository: string, state: 'open' | 'closed'): Promise<GithubPull[]> => {
     // ⛔ A large repository has tens of thousands of closed PRs (2026-09-28: 21k → «exceeded pagination limit», no sweep at all).
     //    Merged twins only matter after the oldest open draft was opened, so the closed listing stops at that time.
@@ -2633,11 +2645,19 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
         .map((line) => line.slice('branch refs/heads/'.length).trim()));
     },
     setLabels: async (repository, number, change) => {
+      if (change.add.startsWith('elanous:swept:')) {
+        const key = `${repository}:${change.add}`;
+        if (!ensuredSweepLabels.has(key)) {
+          execute(['label', 'create', change.add, '--repo', repository, '--color', '6A737D',
+            '--description', 'Draft sweep close reason; reopen this PR to restore it', '--force']);
+          ensuredSweepLabels.add(key);
+        }
+      }
       execute(['pr', 'edit', String(number), '--repo', repository, '--add-label', change.add,
         ...change.remove.flatMap((name) => ['--remove-label', name])]);
     },
-    closeDraft: async (repository, number, comment) => {
-      execute(['pr', 'close', String(number), '--repo', repository, '--comment', comment]);
+    closeDraft: async (repository, number) => {
+      execute(['pr', 'close', String(number), '--repo', repository]);
     },
     getClaimOwner: async (repository, number) => claimCommentOwner(repository, number, execute),
     getActiveClaimOwner: async (repository, number) => activeClaimOwnerFromBodies(await claimCommentsFor(repository, number)),
@@ -3128,7 +3148,13 @@ export interface HarnessCliCommandDeps {
   mission?: HarnessMissionHandler;
   missionLoop?: HarnessMissionLoopHandler;
   /** `harness progress` 가 도는 런 관측을 읽는 자리(시험 주입). 기본은 queryRunningRuns. */
-  progress?: { query?: typeof queryRunningRuns; nowMs?: () => number };
+  progress?: {
+    query?: typeof queryRunningRuns;
+    nowMs?: () => number;
+    bindingRunIds?: typeof launchBindingRunIds;
+    readBinding?: typeof readLaunchBinding;
+    processStartMs?: typeof psProcessStartMs;
+  };
 }
 
 export function installHarnessCliCommand(program: Command, deps: HarnessCliCommandDeps): Command {
@@ -3189,13 +3215,38 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
     });
   harnessCmd.command('progress').description('도는 골마다 진도를 한 표로 읽는다 — 단계 · 진입 시각 · 마지막 진전 · pty (읽기 전용)')
     .option('--json', '같은 행 배열을 JSON 으로 출력')
-    .action((opts: { json?: boolean }) => {
+    .option('--pid <number>', '기록된 로컬 PID 에 연결된 런 한 건만 조회')
+    .action((opts: { json?: boolean; pid?: string }) => {
       try {
+        if (opts.pid !== undefined) {
+          const pid = Number(opts.pid);
+          if (!Number.isSafeInteger(pid) || pid <= 1) {
+            console.error('❌ --pid 는 2 이상의 정수여야 합니다');
+            process.exitCode = 2;
+            return;
+          }
+          const bindings = (deps.progress?.bindingRunIds ?? launchBindingRunIds)()
+            .map((runId) => ({ runId, binding: (deps.progress?.readBinding ?? readLaunchBinding)(runId) }))
+            .filter(({ binding }) => binding?.pid === pid);
+          const binding = bindings.length === 1 && !bindings[0]!.binding?.podName ? bindings[0] : undefined;
+          const startedAt = binding ? (deps.progress?.processStartMs ?? psProcessStartMs)(pid) : null;
+          // ps lstart has second precision. A wider stop-oriented tolerance would attribute a reused PID to this run.
+          const observed = binding && startedAt !== null
+            && startedAt === Math.floor(binding.binding!.startedAt / 1_000) * 1_000;
+          const result = observed
+            ? (deps.progress?.query ?? queryRunningRuns)({ runIds: [binding.runId], caller: 'harness.progress.pid' })
+            : null;
+          const row = result ? buildRunProgressRows(result, (deps.progress?.nowMs ?? Date.now)())
+            .find((item) => item.runId === binding!.runId && item.status !== 'ended-unclosed' && item.status !== 'unknown') : undefined;
+          if (opts.json) console.log(JSON.stringify({ pid, observation: row ? 'observed' : 'unobserved', runId: row?.runId ?? null, progress: row ?? null }));
+          else console.log(row ? `pid ${pid} · ${renderRunProgressTable({ ...result!, entries: result!.entries.filter((item) => item.runId === row.runId) }, (deps.progress?.nowMs ?? Date.now)()).split('\n').slice(1).join('\n')}` : `pid ${pid} · 미관측`);
+          return;
+        }
         const result = (deps.progress?.query ?? queryRunningRuns)({ caller: 'harness.progress' });
         const nowMs = (deps.progress?.nowMs ?? Date.now)();
         if (opts.json) {
           console.log(JSON.stringify(buildRunProgressRows(result, nowMs)));
-          if (result.completeness === 'partial') console.error(renderRunProgressTable(result, nowMs).split('\n')[0]);
+          if (isPartialRunningRuns(result)) console.error(renderRunProgressTable(result, nowMs).split('\n')[0]);
         } else console.log(renderRunProgressTable(result, nowMs));
       } catch (error) {
         console.error(humanErrorLine(error));

package/src/harness/harness-stop.ts

@@ -3,10 +3,12 @@
 // 🩸 2026-09-27: 멈추려면 사람이 PID 둘(harness ask 부모 · self orchestrate 자식)과 Job 이름을 손으로 찾아야 했고,
 //   그 사이 떠 있던 조각이 main 에 병합됐다(#21048). 부모를 죽이면 자식이 PPID 1 고아로 2h36m 더 돌았다(🅞 보고).
 // B 조각(#21171)이 오케스트레이터에 `self-dev-runs/<runId>/pid.json` ⊕ SIGTERM 정리(새 잡 멈춤 · 자기 Job 삭제 · cancelled)를 넣었다.
-// 이 파일은 그 기록과 런 원장·프로세스 표를 읽고, 시작 시각이 확인된 후보에만 신호를 보내며, `elanous.run=<runId>` 라벨 Job 을 지운다.
+// 이 파일은 그 기록과 런 원장·프로세스 표를 읽고, 시작 시각이 확인된 후보에만 신호를 보내며, 라벨 일치 Pod Job 을 지운다.
 //
 // ⛔ 불변식: 기록된 시작 시각과 실제 프로세스 시작 시각이 다르면 신호를 보내지 않는다(PID 재사용 방지).
-// ⛔ 불변식: `elanous.run=<runId>` 라벨이 붙은 Job 만 지운다.
+// ⛔ 불변식: 라벨이 붙은 Job 만 지운다 — `elanous.run=<runId>` · 그 라벨이 0 이면 `elanous.child-run=<runId>` 폴백(자식 런 id 로 쳤을 때).
+//   지우는 것은 라벨 일치 Job 뿐이다: 이름 추측 없음 · Pod 직접 삭제 없음 · namespace 기본값(elanous-test) 불변.
+//   (HARNESS-STOP-POD-LABEL 2026-10-11) 문맥마다 삭제 결과를 넷으로 가르고 관측 `harness.stop` `job-delete`(context·outcome·matchedBy) 로 남긴다.
 // ⛔ 불변식: 짧은 runId 의 후보가 둘 이상이면 프로세스 신호·Job 삭제 전에 중단한다.
 
 import { existsSync, readdirSync, readFileSync, readlinkSync } from 'node:fs';
@@ -79,7 +81,7 @@ export function discoverStopProcesses(runId: string, goalPath: string | null, ta
     const match = /^\s*(\d+)\s+((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\w+\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s+(.+)$/.exec(line);
     if (!match) return { status: 'failed', reason: 'unparseable process table row' };
     const pid = Number(match[1]);
-    const startedAt = Date.parse(match[2]!);
+    const startedAt = Date.parse(`${match[2]!} GMT`);
     if (!Number.isSafeInteger(pid) || !Number.isFinite(startedAt)) return { status: 'failed', reason: 'invalid process table row' };
     if (pid <= 1) continue;
     const args = match[3]!.match(/"[^"]*"|'[^']*'|\S+/g)?.map((part) => part.replace(/^(['"])(.*)\1$/, '$2')) ?? [];
@@ -130,7 +132,9 @@ function stopProcessCwd(pid: number): string | null {
 
 function scanStopProcessTable(runId: string, goalPath: string | null): StopProcessScan {
   let r: ReturnType<typeof spawnSync>;
-  try { r = spawnSync('ps', ['-eo', 'pid=,lstart=,args='], { encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024 }); }
+  try { r = spawnSync('ps', ['-eo', 'pid=,lstart=,args='], {
+    encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, TZ: 'UTC' },
+  }); }
   catch (error) { return { status: 'failed', reason: String(error) }; }
   if (r.error || r.status !== 0 || typeof r.stdout !== 'string') return { status: 'failed', reason: String(r.error ?? r.stderr ?? `ps status ${r.status}`) };
   return discoverStopProcesses(runId, goalPath, r.stdout, stopProcessCwd);
@@ -151,6 +155,19 @@ export interface HarnessStopDeps {
   graceMs: number;
 }
 
+export type HarnessStopJobMatchedBy = 'elanous.run' | 'elanous.child-run';
+
+/**
+ * 문맥 하나의 Pod Job 삭제 결과(HARNESS-STOP-POD-LABEL) — «0개 지움» 의 종류를 가른다.
+ *   deleted N — 라벨 일치 Job N 개 삭제 · none — 두 라벨 다 Job 0(진짜 없음 · Pod 생성 전 등)
+ *   unreachable — kubectl 실패(그 0 을 진짜 0 으로 믿을 수 없다) · pods-only — Job 0 인데 같은 라벨 Pod 잔존
+ */
+export type HarnessStopJobDelete =
+  | { context: string; outcome: 'deleted'; matchedBy: HarnessStopJobMatchedBy; deleted: number }
+  | { context: string; outcome: 'none'; matchedBy: null; deleted: 0 }
+  | { context: string; outcome: 'unreachable'; matchedBy: null; deleted: 0; error: string }
+  | { context: string; outcome: 'pods-only'; matchedBy: null; deleted: 0; podsRemaining: number };
+
 export interface HarnessStopResult {
   runId: string;
   givenRunId?: string;
@@ -161,6 +178,8 @@ export interface HarnessStopResult {
   pidRecordFound: boolean;
   dryRun: boolean;
   jobsDeleted: number;
+  /** 문맥별 Job 삭제 분류 — 출력 한 줄과 `--json` 의 근원. */
+  jobDeletes: HarnessStopJobDelete[];
   contexts: string[];
 }
 
@@ -184,13 +203,15 @@ export function pidRecordFromLaunchBinding(runId: string, registryDir = launchRe
   return { pid: binding.pid, startedAt: binding.startedAt, ...(binding.argv0 ? { argv0: binding.argv0 } : {}) };
 }
 
-/** macOS·Linux 공통 — `ps -o lstart=` 는 로컬 시각 문자열(초 단위)이다. */
+/** macOS·Linux 공통 — UTC 시작 시각과 상태를 같은 ps 관측에서 읽는다. */
 export function psProcessStartMs(pid: number): number | null {
-  const r = spawnSync('ps', ['-o', 'lstart=', '-p', String(pid)], { encoding: 'utf8', timeout: 5_000 });
+  const r = spawnSync('ps', ['-o', 'lstart=,stat=', '-p', String(pid)], {
+    encoding: 'utf8', timeout: 5_000, env: { ...process.env, TZ: 'UTC' },
+  });
   if (r.status !== 0) return null;
-  const text = r.stdout.trim();
-  if (!text) return null;
-  const ms = Date.parse(text);
+  const match = /^\s*((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+\w+\s+\d+\s+\d\d:\d\d:\d\d\s+\d{4})\s+(\S+)\s*$/.exec(r.stdout);
+  if (!match || match[2]!.startsWith('Z')) return null;
+  const ms = Date.parse(`${match[1]!} GMT`);
   return Number.isFinite(ms) ? ms : null;
 }
 
@@ -231,6 +252,56 @@ export function defaultHarnessStopDeps(overrides: Partial<HarnessStopDeps> = {},
   };
 }
 
+/** Pod Job 라벨 — `elanous.run` = 부모(오케스트레이터) 런 id · `elanous.child-run` = 자식 런 id(self-implement-pod podRunLabels). */
+const POD_JOB_LABELS = ['elanous.run', 'elanous.child-run'] as const;
+
+/** `kubectl get -o name` 출력에서 `<prefix>` 로 시작하는 줄 수를 센다. */
+function countOutputLines(stdout: string, prefix: string): number {
+  return stdout.split('\n').filter((line) => line.startsWith(prefix)).length;
+}
+
+/**
+ * `kubectl delete job -o name` 출력에서 삭제된 Job 줄 수를 센다.
+ * `-o name` 출력은 `job.batch/<name>` 한 줄씩이지만, 일부 kubectl 버전·설정에서는
+ * `job.batch "<name>" deleted` 꼴도 나타난다(#26194). 두 꼴을 모두 센다.
+ */
+function countDeletedJobLines(stdout: string): number {
+  return stdout.split('\n').filter((line) => /^job\.batch(?:\/|\s+")/.test(line.trim())).length;
+}
+
+/** 문맥 하나의 Pod Job 삭제 — 결과를 넷(deleted·none·unreachable·pods-only)으로 가르고 문맥마다 관측 `harness.stop` `job-delete` 를 남긴다. */
+function deleteRunPodJobs(deps: HarnessStopDeps, runId: string, context: string): HarnessStopJobDelete {
+  const unreachable = (stderr: string): HarnessStopJobDelete => {
+    const error = stderr.slice(0, 200);
+    debug.log('harness.stop', 'job-delete', { runId, context, outcome: 'unreachable', matchedBy: null, error }, { level: 'warn' });
+    return { context, outcome: 'unreachable', matchedBy: null, deleted: 0, error };
+  };
+  // ① `elanous.run=<runId>` — 0 이면 `elanous.child-run=<runId>` 로 한 번 더 고른다(자식 런 id 로 쳤을 때). 지우는 것은 라벨 일치 Job 뿐이다.
+  for (const label of POD_JOB_LABELS) {
+    // `-o name` → «job.batch/<name>» 한 줄씩. 맨 출력은 «job.batch "<name>" deleted» 라 «job.batch/» 로만 세면
+    //   지워도 늘 0 이었다(10-11 · 여섯 번 «0개 지움» 뒤 Pod Terminating). 두 꼴을 다 센다(#26194).
+    const r = deps.kubectl(['--context', context, '-n', deps.namespace, 'delete', 'job', '-l', `${label}=${runId}`, '--wait=false', '-o', 'name']);
+    if (r.status !== 0) return unreachable(r.stderr);
+    const deleted = countDeletedJobLines(r.stdout);
+    if (deleted > 0) {
+      debug.log('harness.stop', 'job-delete', { runId, context, outcome: 'deleted', matchedBy: label, deleted });
+      return { context, outcome: 'deleted', matchedBy: label, deleted };
+    }
+  }
+  // ② 두 라벨 다 Job 0 — 같은 라벨 Pod(`get pods -l <라벨>=<runId>`)로 none 과 pods-only 를 가른다. Pod 는 직접 지우지 않는다.
+  for (const label of POD_JOB_LABELS) {
+    const p = deps.kubectl(['--context', context, '-n', deps.namespace, 'get', 'pods', '-l', `${label}=${runId}`, '-o', 'name']);
+    if (p.status !== 0) return unreachable(p.stderr);
+    const podsRemaining = countOutputLines(p.stdout, 'pod/');
+    if (podsRemaining > 0) {
+      debug.log('harness.stop', 'job-delete', { runId, context, outcome: 'pods-only', matchedBy: null, podsRemaining });
+      return { context, outcome: 'pods-only', matchedBy: null, deleted: 0, podsRemaining };
+    }
+  }
+  debug.log('harness.stop', 'job-delete', { runId, context, outcome: 'none', matchedBy: null });
+  return { context, outcome: 'none', matchedBy: null, deleted: 0 };
+}
+
 export async function stopHarnessRun(runId: string, deps: HarnessStopDeps, contexts?: readonly string[], dryRun = false): Promise<HarnessStopResult> {
   if (!RUN_ID.test(runId)) throw new Error(`invalid run id: ${runId}`);
   const given = runId;
@@ -297,15 +368,9 @@ export async function stopHarnessRun(runId: string, deps: HarnessStopDeps, conte
   }
   // ── ⓑ Pod Job (라벨로만) ───────────────────────────────────
   const targets = dryRun ? [] : contexts && contexts.length > 0 ? [...contexts] : deps.kubeContexts();
-  let jobsDeleted = 0;
-  for (const context of targets) {
-    // `-o name` → «job.batch/<name>» 한 줄씩. 맨 출력은 «job.batch "<name>" deleted» 라 «job.batch/» 로만 세면
-    //   지워도 늘 0 이었다(10-11 · 여섯 번 «0개 지움» 뒤 Pod Terminating). 두 꼴을 다 센다.
-    const r = deps.kubectl(['--context', context, '-n', deps.namespace, 'delete', 'job', '-l', `elanous.run=${runId}`, '--wait=false', '-o', 'name']);
-    if (r.status === 0) jobsDeleted += r.stdout.split('\n').filter((line) => /^job\.batch(?:\/|\s+")/.test(line.trim())).length;
-    else debug.log('harness.stop', 'job-delete-failed', { runId, context, error: r.stderr.slice(0, 200) }, { level: 'warn' });
-  }
-  const result: HarnessStopResult = { runId, ...(given !== runId ? { givenRunId: given } : {}), process: processState, ...(record ? { pid: record.pid } : {}), candidates, scanned: scan.status === 'ok', pidRecordFound: record !== null, dryRun, jobsDeleted, contexts: targets };
+  const jobDeletes = targets.map((context) => deleteRunPodJobs(deps, runId, context));
+  const jobsDeleted = jobDeletes.reduce((sum, job) => sum + job.deleted, 0);
+  const result: HarnessStopResult = { runId, ...(given !== runId ? { givenRunId: given } : {}), process: processState, ...(record ? { pid: record.pid } : {}), candidates, scanned: scan.status === 'ok', pidRecordFound: record !== null, dryRun, jobsDeleted, jobDeletes, contexts: targets };
   debug.log('harness.stop', 'stopped', { runId, process: processState, jobsDeleted, contexts: targets.length });
   return result;
 }
@@ -326,6 +391,15 @@ export function formatHarnessStop(r: HarnessStopResult): string {
     ...r.candidates.map(({ pid, startedAt, via }) => `  후보: pid ${pid} · 시작 ${new Date(startedAt).toISOString()} · ${via}`),
     r.dryRun
       ? `  Pod Job: dry-run(조회·삭제하지 않음 · 라벨 elanous.run=${r.runId})`
-      : `  Pod Job: ${r.jobsDeleted}개 지움 (문맥 ${r.contexts.length}개 · 라벨 elanous.run=${r.runId})`,
+      : `  Pod Job: ${r.jobsDeleted}개 지움 (문맥 ${r.contexts.length}개 · 라벨 elanous.run=${r.runId} · child-run 폴백)`,
+    ...r.jobDeletes.map(formatHarnessStopJobDelete),
   ].join('\n');
 }
+
+/** 문맥 하나의 Pod Job 결과 줄 — none·unreachable·pods-only 는 서로 다른 문면으로 갈라 읽힌다. */
+function formatHarnessStopJobDelete(job: HarnessStopJobDelete): string {
+  if (job.outcome === 'deleted') return `    ${job.context}: ${job.deleted}개 지움 (라벨 ${job.matchedBy})`;
+  if (job.outcome === 'pods-only') return `    ${job.context}: Job 0 · 같은 라벨 Pod ${job.podsRemaining} 남음 (Pod 는 직접 지우지 않는다)`;
+  if (job.outcome === 'unreachable') return `    ${job.context}: 못 닿음 (kubectl 실패: ${job.error})`;
+  return `    ${job.context}: 없음 (라벨 맞는 Job 0)`;
+}