elanous 0.2.27 → 0.2.28

package/src/dashboard/first-screen-band.ts

@@ -106,6 +106,8 @@ export interface FirstScreenBandInput {
   readonly width: number;
   readonly daemon: boolean;
   readonly link?: TuiDaemonLink;
+  /** Renders the three available-action rows and the example row in this locale; `undefined` keeps the historical band. */
+  readonly locale?: 'ko' | 'en';
   readonly pwa?: {
     readonly tailnet?: string | null;
     readonly lan?: string | null;
@@ -138,10 +140,37 @@ function fitCells(text: string, limit: number): string {
   return result;
 }
 
+// First-run guidance: three rows of available actions plus one immediately-typeable
+// example row, per locale. Every row names something the empty TUI can really do.
+const GUIDANCE: Record<'ko' | 'en', {
+  readonly actions: readonly [string, string, string];
+  readonly example: string;
+}> = {
+  ko: {
+    actions: [
+      '· 대화 — 무엇이든 자연어로 물어보고 시켜보세요',
+      '· 명령 — /help 로 전체 명령을 보세요',
+      '· 스킬 — /run-skill <이름> 으로 설치된 스킬을 돌리세요',
+    ],
+    example: '바로 입력해 보세요: 무엇을 할 수 있어?',
+  },
+  en: {
+    actions: [
+      '· Chat — ask for anything in plain language',
+      '· Commands — /help lists every command',
+      '· Skills — /run-skill <name> runs an installed skill',
+    ],
+    example: 'Try typing: what can you do?',
+  },
+};
+
 /** A startup transcript band; never includes credentials or a partial address. */
 export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
   const width = Number.isFinite(input.width) ? Math.max(0, Math.floor(input.width)) : 0;
-  const fit = (text: string): string => text.slice(0, width);
+  // The historical band is mixed: the link row speaks Korean, the remaining lines English.
+  // An explicit locale unifies them; `undefined` must keep every pinned line byte-identical.
+  const linkKorean = input.locale !== 'en';
+  const plainKorean = input.locale === 'ko';
   const address = [input.pwa?.tailnet, input.pwa?.lan, input.pwa?.loopback]
     .map((candidate) => {
       if (!candidate) return null;
@@ -154,32 +183,53 @@ export function buildFirstScreenBand(input: FirstScreenBandInput): string[] {
       }
     })
     .find((candidate) => candidate !== null);
-  const fallback = input.pwa === undefined ? 'PWA: not checked' : 'PWA: unavailable';
+  const fallback = input.pwa === undefined
+    ? (plainKorean ? 'PWA: 확인 안 함' : 'PWA: not checked')
+    : (plainKorean ? 'PWA: 사용할 수 없음' : 'PWA: unavailable');
   const addressLine = address ? `PWA: ${address}` : fallback;
 
   const daemonLine = (() => {
     const link = input.link;
-    if (!link) return `elanous | daemon: ${input.daemon ? 'online' : 'offline'}`;
-    if (link.status === 'checking') return 'elanous | 데몬: 확인 중';
+    if (!link) return plainKorean
+      ? `elanous | 데몬: ${input.daemon ? '켜짐' : '꺼짐'}`
+      : `elanous | daemon: ${input.daemon ? 'online' : 'offline'}`;
+    if (link.status === 'checking') return linkKorean ? 'elanous | 데몬: 확인 중' : 'elanous | daemon: checking';
     if (link.status === 'connected') {
       let address: string;
       try {
         const url = new URL(link.address);
         address = ['http:', 'https:'].includes(url.protocol) && url.hostname ? url.origin : '';
       } catch { address = ''; }
-      const line = `elanous | 데몬: 연결됨${address ? ` (${address})` : ''}`;
-      return cellWidth(line) <= width ? line : 'elanous | 데몬: 연결됨';
+      const bare = linkKorean ? 'elanous | 데몬: 연결됨' : 'elanous | daemon: connected';
+      const line = `${bare}${address ? ` (${address})` : ''}`;
+      return cellWidth(line) <= width ? line : bare;
+    }
+    if (link.status === 'error') {
+      return linkKorean ? `elanous | 데몬: ${link.stage} 조회 오류` : `elanous | daemon: ${link.stage} lookup error`;
     }
-    if (link.status === 'error') return `elanous | 데몬: ${link.stage} 조회 오류`;
-    const bare = `elanous | 데몬: ${link.status === 'absent' ? '없음' : '응답 없음'}`;
+    const bare = linkKorean
+      ? `elanous | 데몬: ${link.status === 'absent' ? '없음' : '응답 없음'}`
+      : `elanous | daemon: ${link.status === 'absent' ? 'absent' : 'unhealthy'}`;
     if (!link.startCommand || CONTROL_CHARS.test(link.startCommand)) return bare;
-    const line = `${bare} · 시작: ${link.startCommand}`;
+    const line = `${bare} · ${linkKorean ? '시작' : 'start'}: ${link.startCommand}`;
     return cellWidth(line) <= width ? line : bare;
   })();
 
-  return [
-    input.link ? fitCells(daemonLine, width) : fit(daemonLine),
-    addressLine.length <= width ? addressLine : fit(address ? 'PWA: address available' : fallback),
-    fit('Type a message to begin | /help for commands'),
+  const hintLine = 'Type a message to begin | /help for commands';
+
+  const statusRows = [
+    fitCells(daemonLine, width),
+    cellWidth(addressLine) <= width
+      ? addressLine
+      : fitCells(address ? (plainKorean ? 'PWA: 주소 확인됨' : 'PWA: address available') : fallback, width),
   ];
+  // The historical band folds its guidance into one mixed-language hint row.
+  // An explicit locale renders the same guidance as three available-action rows
+  // plus one immediately-typeable example row, in that locale — on every screen
+  // state (empty, checking, absent, unhealthy, error) because none of these
+  // rows depends on the daemon link or the PWA lookup.
+  const guidanceRows = input.locale
+    ? [...GUIDANCE[input.locale].actions, GUIDANCE[input.locale].example].map((row) => fitCells(row, width))
+    : [fitCells(hintLine, width)];
+  return [...statusRows, ...guidanceRows];
 }

package/src/dashboard/index.ts

@@ -643,6 +643,7 @@ import { activeCodexAccountView } from '../oauth/codex-account-store.js';
 import { buildDashboardStatusLines } from './dashboard-status-lines.js';
 import { readSlashContextNow, seatsNowLine } from '../context-bus/context-now-surfaces.js';
 import { buildFirstScreenBand, resolveTuiDaemonLink, type TuiDaemonLink } from './first-screen-band.js';
+import { detectLocale } from '../expression/locale.js';
 import { runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import {
   workingDirSegment, sessionCwdSegment, modelSegment, gitSegment,
@@ -1896,18 +1897,20 @@ export function renderDashboardFirstScreenBand(input: {
   readonly history: ReadonlyArray<{ role: string }>;
   readonly lines: string[];
   readonly width: number;
+  /** Renders the localized guidance rows; `undefined` keeps the historical mixed band. */
+  readonly locale?: 'ko' | 'en';
   readonly draw: () => void;
   readonly observe: (data: { daemon: boolean; hasPwa: boolean; hasTailnet: boolean }) => void;
   readonly show?: () => Promise<Pick<NexusShowResult, 'status' | 'urls'>>;
   readonly daemonLink?: () => Promise<TuiDaemonLink>;
 }): Promise<void> {
   if (input.history.some((message) => message.role !== 'system')) return Promise.resolve();
-  const band = buildFirstScreenBand({ width: input.width, daemon: false, link: { status: 'checking' } });
+  const band = buildFirstScreenBand({ width: input.width, daemon: false, link: { status: 'checking' }, locale: input.locale });
   input.lines.unshift(...band);
   const daemonLink = input.daemonLink ?? resolveTuiDaemonLink;
   const linkPending = Promise.resolve().then(() => daemonLink()).catch((): TuiDaemonLink => ({ status: 'error', stage: 'health' })).then((link) => {
     if (input.lines[0] !== band[0]) return;
-    input.lines[0] = buildFirstScreenBand({ width: input.width, daemon: false, link })[0]!;
+    input.lines[0] = buildFirstScreenBand({ width: input.width, daemon: false, link, locale: input.locale })[0]!;
     try { input.draw(); } catch { /* screen may have closed */ }
   });
   const show = input.show ?? (() => runNexusShow({ format: 'json', out: { log: () => {}, error: () => {} } }));
@@ -1921,7 +1924,7 @@ export function renderDashboardFirstScreenBand(input: {
     const hasTailnet = !!pwa?.tailnet;
     observe({ daemon, hasPwa, hasTailnet });
     if (input.lines[1] !== band[1]) return;
-    input.lines[1] = buildFirstScreenBand({ width: input.width, daemon, pwa })[1]!;
+    input.lines[1] = buildFirstScreenBand({ width: input.width, daemon, pwa, locale: input.locale })[1]!;
     try { input.draw(); } catch { /* screen may have closed */ }
   }).catch(() => {
     observe({ daemon: false, hasPwa: false, hasTailnet: false });
@@ -15703,6 +15706,8 @@ Mode- and sync-specific instructions are injected per-turn when relevant — do
       history: chat.history,
       lines: chatLines,
       width: Math.max(0, termSize().cols - 4),
+      // The band ships ko/en only; any other detected locale keeps the English rows.
+      locale: detectLocale() === 'ko' ? 'ko' : 'en',
       draw: () => draw(),
       observe: (data) => { try { debug.log('dashboard.first-screen-band', 'resolved', data); } catch { /* observation is best-effort */ } },
     });

package/src/dashboard/skill-detection-runtime.ts

@@ -7,16 +7,26 @@ import {
 } from '../skills/router.js';
 import type { SkillIndexEntry } from '../skills/index.js';
 import type { SkillTier } from '../skills/runner.js';
-import type { LLMMessage } from '../llm.js';
+import * as llm from '../llm.js';
+import { resolveRoleLlm } from '../user-config.js';
+import { debug } from '../debug/log.js';
 
 export interface DashboardSkillDetectionRuntimeDeps {
   llmFallback: boolean;
   keywordScoreThreshold: number;
   llmConfidenceThreshold: number;
   streamLLM: (
-    messages: LLMMessage[],
+    messages: llm.LLMMessage[],
     onDelta: (chunk: string, full: string) => void,
-    opts: { signal?: AbortSignal; maxTokens?: number; temperature?: number },
+    opts: {
+      signal?: AbortSignal;
+      maxTokens?: number;
+      temperature?: number;
+      /** classify role pin — resolveRoleLlm('classify')가 고른 모델·프로바이더. */
+      model?: string;
+      provider?: (typeof llm.PROVIDERS)[string];
+      usageRole?: 'classify';
+    },
   ) => Promise<string>;
   /** Active model tier — enables tier-aware full-menu LLM routing in
    *  detectLLM (T1 frontier models route the whole menu when keyword is
@@ -69,10 +79,20 @@ export async function detectDashboardSkillRoute(
   if (!deps.llmFallback) return keywordDetection;
 
   const classify = async (prompt: string, signal?: AbortSignal): Promise<LLMClassifyResult> => {
+    const resolved = resolveRoleLlm('classify');
+    const provider = llm.PROVIDERS[resolved.provider];
+    if (!provider) throw new Error(`Unknown classify provider: ${resolved.provider}`);
+    debug.log('llm.role-pin', 'resolved', {
+      site: 'skill-detection-runtime',
+      role: 'classify',
+      model: resolved.model,
+      provider: resolved.provider,
+      source: resolved.source,
+    });
     const raw = await deps.streamLLM(
       [{ role: 'user', content: prompt }],
       () => {},
-      { signal, maxTokens: 120, temperature: 0 },
+      { signal, maxTokens: 120, temperature: 0, model: resolved.model, provider, usageRole: 'classify' },
     );
     return parseClassifier(raw);
   };

package/src/domains/morning-report.ts

@@ -22,6 +22,8 @@ export interface MorningReportOpts {
   heatmapImageUrl?: string;
   /** S3 상세 리포트 업로드 여부(기본 true). 테스트는 false 로 부작용 차단. */
   upload?: boolean;
+  /** 시장서사 LLM model 명시(A/B). 미지정이면 지금과 같은 기본 provider 경로(providerFor(cfg)). */
+  model?: string;
 }
 
 /** 밤사이 소스를 종합한 아침 에센셜(텔레그램) 조립. 상세는 S3 링크로. */
@@ -38,7 +40,7 @@ export async function composeMorningReport(now: Date = new Date(), opts: Morning
     catch { uploaded = null; }
   }
 
-  const narrative = opts.narrate ? await synthesizeEssentialBrief(md) : '';
+  const narrative = opts.narrate ? await synthesizeEssentialBrief(md, { model: opts.model }) : '';
 
   // 결론-우선 상단 블록(매력도 Δ · 섹터순환 · 캡스톤) — PWA 대시보드 데이터 재사용. fail-soft.
   let heatmap = null, capstone = null;

package/src/github/pr-labels.ts

@@ -3,6 +3,12 @@ export const IDEA_APPROVAL_LIMIT = 10;
 export const IDEA_STALE_DAYS = 7;
 export const STALLED_DRAFT_HOURS = 24;
 export const CLAIM_IDLE_HOURS = 6;
+export const PR_LABEL_NAMES = {
+  running: 'elanous:running',
+  stalled: 'elanous:stalled',
+  superseded: 'elanous:superseded',
+  needsRebase: 'elanous:needs-rebase',
+} as const;
 
 export type PrLabelAxis = 'state' | 'addon' | 'origin' | 'risk';
 export type PrLabelApplier = 'harness' | 'launcher' | 'sweeper' | 'session' | 'human';
@@ -24,14 +30,14 @@ export interface PrLabelDefinition {
 }
 
 export const PR_LABELS = [
-  { name: 'elanous:running', axis: 'state', color: '1D76DB', description: 'Harness run or session is actively handling a draft PR', appliedBy: ['harness', 'session'], sweep: { action: 'mark-stalled', when: 'run-ended' } },
-  { name: 'elanous:stalled', axis: 'state', color: 'D93F0B', description: 'Incomplete draft requiring human attention', appliedBy: ['harness', 'sweeper'], sweep: { action: 'close', afterHours: STALLED_DRAFT_HOURS } },
+  { name: PR_LABEL_NAMES.running, axis: 'state', color: '1D76DB', description: 'Harness run or session is actively handling a draft PR', appliedBy: ['harness', 'session'], sweep: { action: 'mark-stalled', when: 'run-ended' } },
+  { name: PR_LABEL_NAMES.stalled, axis: 'state', color: 'D93F0B', description: 'Incomplete draft requiring human attention', appliedBy: ['harness', 'sweeper'], sweep: { action: 'close', afterHours: STALLED_DRAFT_HOURS } },
   { name: 'elanous:idea-approval', axis: 'state', color: '0E8A16', description: 'Completed, ready PR awaiting human approval', appliedBy: ['launcher'], sweep: { action: 'none' } },
-  { name: 'elanous:superseded', axis: 'state', color: '6A737D', description: 'Another PR has already merged the same work', appliedBy: ['sweeper', 'session'], sweep: { action: 'close' } },
+  { name: PR_LABEL_NAMES.superseded, axis: 'state', color: '6A737D', description: 'Another PR has already merged the same work', appliedBy: ['sweeper', 'session'], sweep: { action: 'close' } },
   { name: 'elanous:keep', axis: 'addon', color: 'BFDADC', description: 'Human requested that the PR be kept open', appliedBy: ['human'], sweep: { action: 'exclude' } },
   { name: 'elanous:release-hold', axis: 'addon', color: 'D4C5F9', description: 'Exclude from release notes until verified in production', appliedBy: ['launcher', 'session', 'human'], sweep: { action: 'none' } },
   { name: 'elanous:idea-stale', axis: 'addon', color: 'FBCA04', description: 'Approval pending beyond the notification threshold', appliedBy: ['sweeper'], sweep: { action: 'notify', afterDays: IDEA_STALE_DAYS } },
-  { name: 'elanous:needs-rebase', axis: 'addon', color: 'E99695', description: 'Approval blocked by conflicts or failing checks', appliedBy: ['sweeper'], sweep: { action: 'block-approval' } },
+  { name: PR_LABEL_NAMES.needsRebase, axis: 'addon', color: 'E99695', description: 'Approval blocked by conflicts or failing checks', appliedBy: ['sweeper', 'session'], sweep: { action: 'block-approval' } },
   { name: 'elanous:bench', axis: 'addon', color: 'C5DEF5', description: 'Bench arm output: never landed or swept; the owner harvests the winner onto main', appliedBy: ['harness'], sweep: { action: 'none' } },
   { name: 'elanous:harvestable', axis: 'addon', color: 'FBCA04', description: 'Pod terminal marked this PR for harvest', appliedBy: ['harness'], sweep: { action: 'close', afterHours: STALLED_DRAFT_HOURS } },
   { name: 'elanous:from-harness', axis: 'origin', color: 'C5DEF5', description: 'Launched from a harness goal', appliedBy: ['harness'], sweep: { action: 'none' } },

package/src/graph-runner/runner.ts

@@ -27,6 +27,43 @@ import { releaseResumeAcceptedRegressions, releaseResumeGateExecutor, releaseRes
 
 type BashRun = WorkflowDeps['runBash'];
 const DEFAULT_BASH_TIMEOUT_MS = 5 * 60 * 1_000;
+// Independent of graph YAML and recipe snapshots: an already-wrong saved binding must fail closed.
+const RELEASE_NODE_COMMANDS: Readonly<Record<string, { recipe: string; command?: string }>> = {
+  'version-release': { recipe: 'cmd:version-release', command: 'bun scripts/release-loop/version-node.ts release --json' },
+  cutoff: { recipe: 'cmd:cutoff', command: 'bun scripts/release-loop/node-verdict.ts cutoff' },
+  'checklist-gate': { recipe: 'cmd:checklist-gate', command: 'bun scripts/release-loop/checklist-gate-node.ts' },
+  prefetch: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
+  gate: { recipe: 'cmd:gate', command: 'bun scripts/release-loop/gate-node.ts --json' },
+  'mac-smoke': { recipe: 'cmd:mac-smoke', command: 'bun scripts/release-loop/mac-smoke-node.ts' },
+  'export-check': { recipe: 'cmd:export-check', command: 'bun scripts/release-loop/export-check-node.ts' },
+  pwa: { recipe: 'cmd:pwa', command: 'bun scripts/release-loop/node-verdict.ts pwa' },
+  prepare: { recipe: 'cmd:prepare', command: 'bun scripts/release-loop/prepare-node.ts' },
+  upgrade: { recipe: 'cmd:upgrade', command: 'bun scripts/release-loop/upgrade-node.ts' },
+  tui: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
+  docs: { recipe: 'cmd:docs', command: 'bun scripts/release-loop/docs-node.ts --json' },
+  'known-issues': { recipe: 'cmd:known-issues', command: 'bun scripts/release-loop/known-issues-node.ts' },
+  'notes-check': { recipe: 'cmd:notes-check', command: 'bun scripts/announce-loop/check-node.ts --json' },
+  'auto-approve': { recipe: 'cmd:auto-approve', command: 'bun scripts/release-loop/auto-approve-node.ts' },
+  'approve-publish': { recipe: 'approval:publish' },
+  publish: { recipe: 'cmd:publish-command', command: 'bun scripts/release-loop/publish-node.ts' },
+  'npm-publish': { recipe: 'cmd:npm-publish', command: 'bun scripts/release-loop/npm-publish-node.ts' },
+  'docs-land': { recipe: 'cmd:docs-land', command: 'bun scripts/release-loop/docs-land-node.ts' },
+  verify: { recipe: 'cmd:verify', command: 'bun scripts/release-loop/verify-node.ts' },
+  'vault-note': { recipe: 'cmd:vault-note', command: 'bun scripts/release-loop/vault-note-node.ts' },
+  'release-story': { recipe: 'cmd:release-story', command: 'bun scripts/release-story/draft.ts --graph' },
+  'ops-upgrade': { recipe: 'cmd:ops-upgrade', command: 'bun scripts/release-loop/ops-upgrade-node.ts' },
+  'version-dev-bump': { recipe: 'cmd:version-dev-bump', command: 'bun scripts/release-loop/version-node.ts dev-bump --json' },
+  done: { recipe: 'none' },
+  failed: { recipe: 'none' },
+};
+
+function assertReleaseCommandBinding(node: GraphNodeSpec, command: string | undefined, terminal: boolean): void {
+  const expected = RELEASE_NODE_COMMANDS[node.nodeId];
+  if (!expected || node.recipe !== expected.recipe || command !== expected.command ||
+    terminal !== (node.nodeId === 'done' || node.nodeId === 'failed')) {
+    throw new Error(`release node dispatch mismatch before execution: ${node.nodeId}`);
+  }
+}
 
 export interface GraphRunState {
   graphId: string;
@@ -54,7 +91,9 @@ export interface GraphRunState {
   graphPath?: string;
   variant?: { overlayId: string; goal: string; plan: GraphVariantPlan };
   parentRunId?: string;
-  unitCalls?: Array<{ node: string; unit: string; version: number; hash: string; childRunId: string; exit: string; steps: number }>;
+  /** The entry chosen by a parent call; absent for existing single-entry runs. */
+  entryNodeId?: string;
+  unitCalls?: Array<{ node: string; unit: string; version: number; hash: string; childRunId: string; exit: string; steps: number; entry?: string }>;
   growth?: GraphGrowth[];
   growthRejections?: Array<{ from: string; outcome: string; reason: string }>;
   growthPark?: { from: string; outcome: string; reason: string; decisionId: string; decisionRef: string; growth: GraphGrowth; command?: GrowthCommand; approval?: string };
@@ -84,7 +123,7 @@ export interface GraphRunOptions {
   releaseGateExecutor?: { executor: string; host?: string };
   useCurrentGraph?: boolean;
   /** Internal unit invocation context, propagated only by runGraph. */
-  unitContext?: { parentRunId: string; ancestors: readonly string[]; remainingSteps: number };
+  unitContext?: { parentRunId: string; ancestors: readonly string[]; remainingSteps: number; entryNodeId?: string };
   /**
    * RELEASE-LEDGER-UNIVERSE — stamp every cmd: child with this run's ledger root (`ELANOUS_STATE_DIR`).
    * Without it a child launched from a non-leader tree (`bun scripts/...` with cwd = that tree) re-resolves
@@ -404,7 +443,14 @@ function nextNode(edges: readonly GraphEdgeSpec[], nodeId: string, exitOutcome:
 
 type ResolvedUnit = { path: string; template: GraphTemplateSpec; hash: string };
 
-function resolveUnit(call: string, callerPath: string): ResolvedUnit {
+export class UnitNotFoundError extends Error {
+  constructor(call: string) {
+    super(`unit not found: ${call}`);
+    this.name = 'UnitNotFoundError';
+  }
+}
+
+export function resolveUnit(call: string, callerPath: string): ResolvedUnit {
   const [id, requested] = call.split('@');
   const repo = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
   const directories = [join(dirname(callerPath), 'units'), dirname(callerPath), join(repo, 'graphs', 'units'), join(getElanousConfigDir(), 'graphs', 'units')];
@@ -424,16 +470,24 @@ function resolveUnit(call: string, callerPath: string): ResolvedUnit {
     if (matches.length > 1) throw new Error(`ambiguous unit: ${call}`);
     if (matches.length) return matches[0]!;
   }
-  throw new Error(`unit not found: ${call}`);
+  throw new UnitNotFoundError(call);
 }
 
-function validateUnitCalls(graph: GraphTemplateSpec, path: string, ancestors: readonly string[] = []): Map<string, ResolvedUnit> {
+export function validateUnitCalls(graph: GraphTemplateSpec, path: string, ancestors: readonly string[] = [], onMissing?: (call: string) => void): Map<string, ResolvedUnit> {
   if (ancestors.includes(graph.graphId)) throw new Error(`unit cycle: ${[...ancestors, graph.graphId].join(' -> ')}`);
   if (ancestors.length > 3) throw new Error('unit nesting exceeds depth 3');
   const result = new Map<string, ResolvedUnit>();
   for (const node of graph.nodes) {
     if (node.kind !== 'subgraph' || node.call === undefined) continue;
-    const unit = resolveUnit(node.call!, path);
+    let unit: ResolvedUnit;
+    try { unit = resolveUnit(node.call!, path); } catch (error) {
+      if (error instanceof UnitNotFoundError && onMissing) { onMissing(node.call!); continue; }
+      throw error;
+    }
+    const selectedEntry = node.callEntry ?? unit.template.entryNode;
+    if (!(unit.template.unit?.entries ?? [unit.template.entryNode]).includes(selectedEntry)) {
+      throw new Error(`unit entry mismatch: ${node.nodeId} -> ${selectedEntry}`);
+    }
     const contract = node.contract!;
     const edge = graph.edges.find(e => e.from === node.nodeId);
     if (!unit.template.unit || contract.inputs.length !== unit.template.unit.inputs.length ||
@@ -445,7 +499,7 @@ function validateUnitCalls(graph: GraphTemplateSpec, path: string, ancestors: re
       debug.log('graph.unit', 'contract-mismatch', { graphId: graph.graphId, nodeId: node.nodeId, call: node.call });
       throw new Error(`unit contract mismatch: ${node.nodeId} -> ${node.call}`);
     }
-    validateUnitCalls(unit.template, unit.path, [...ancestors, graph.graphId]);
+    validateUnitCalls(unit.template, unit.path, [...ancestors, graph.graphId], onMissing);
     result.set(node.nodeId, unit);
   }
   return result;
@@ -492,6 +546,13 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   if (variant && !variant.ok) throw new Error(`graph variant rejected: ${JSON.stringify(variant.rejections)}`);
   if (variant?.ok) graph = variant.template;
   const units = validateUnitCalls(graph, path, options.unitContext?.ancestors);
+  const unitEntryNode = options.unitContext?.entryNodeId ?? saved?.entryNodeId ?? graph.entryNode;
+  if (saved?.entryNodeId !== undefined && options.unitContext?.entryNodeId !== undefined && saved.entryNodeId !== options.unitContext.entryNodeId) {
+    throw new Error('unit entry changed on resume');
+  }
+  if ((options.unitContext || saved?.entryNodeId !== undefined) && !(graph.unit?.entries ?? [graph.entryNode]).includes(unitEntryNode)) {
+    throw new Error(`unit entry mismatch: ${unitEntryNode}`);
+  }
   const variantSource = variant?.ok ? stringifyYaml({ ...document,
     nodes: graph.nodes.map((node, index) => ({
       ...((document.nodes as Record<string, unknown>[])[index] ?? {}), node_id: node.nodeId, kind: node.kind,
@@ -537,6 +598,14 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     if (!resolved.command && !resolved.prompt && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
   }
   const graphId = safeSegment(graph.graphId);
+  const isReleaseLoop = graphId === 'release-loop';
+  // A copied or saved release graph is still a release graph. Its path cannot grant or revoke
+  // permission to dispatch a command; only the graph identity and this independent table can.
+  const enforceReleaseCommandBindings = isReleaseLoop;
+  if (enforceReleaseCommandBindings) {
+    for (const node of graph.nodes) assertReleaseCommandBinding(node,
+      resolveNodeRecipe(node, recipes, catalogRoles).command?.command, graph.terminalNodes.includes(node.nodeId));
+  }
   if (saved && graphId !== saved.graphId) {
     if (options.fromNodeId && graphMode === 'current') throw new Error('graph or recipes changed since failed run');
     throw new Error(`run identity mismatch: ${saved.graphId}/${saved.runId}`);
@@ -562,7 +631,9 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     : { graphId, runId, startedAt: new Date().toISOString(), ...runnerOwner, status: 'running', path: [], nodes: [], sourceHash: approvalSourceHash,
       graphSnapshot: { graphSha: createHash('sha256').update(variantSource).digest('hex'), recipesSha: createHash('sha256').update(recipeSource).digest('hex') },
       graphPath: resolve(path), ...(variant?.ok ? { variant: { overlayId: variant.overlay.overlayId, ...options.variant! } } : {}),
-      ...(options.input === undefined ? {} : { input: options.input }), executed: 0, dryRun: options.dryRun === true, statePath };
+      ...(options.input === undefined ? {} : { input: options.input }),
+      ...(options.unitContext?.entryNodeId === undefined ? {} : { entryNodeId: options.unitContext.entryNodeId }),
+      executed: 0, dryRun: options.dryRun === true, statePath };
   if (options.resumeRunId && graphMode === 'snapshot' && state.sourceHash && state.sourceHash !== approvalSourceHash) {
     throw new Error('graph snapshot changed since run started');
   }
@@ -594,7 +665,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         const reported = lastJsonObject(prior.output)?.outcome;
         const next = nextNode(graph.edges, prior.nodeId, prior.ok ? 'ok' : 'fail', typeof reported === 'string' ? reported : undefined);
         if (next !== recorded.nodeId) throw new Error('saved run path does not follow graph edges');
-      } else if (recorded.nodeId !== graph.entryNode) throw new Error('saved run path does not start at entry node');
+      } else if (recorded.nodeId !== unitEntryNode) throw new Error('saved run path does not start at entry node');
       if (i < from && !recorded.ok) throw new Error('cannot preserve a failed predecessor when resuming');
       const approved = resolveNodeRecipe(spec, recipes, catalogRoles).approval;
       if (approved && i >= from) throw new Error('cannot restart across an approval decision');
@@ -736,7 +807,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   if (options.resumeRunId && !options.fromNodeId) {
     const previousStatus = state.status;
     Object.assign(state, runnerOwner);
-    state.resume = { from: state.pending?.nodeId ?? state.path.at(-1) ?? graph.entryNode, at: new Date().toISOString(), previousStatus, graph: graphMode };
+    state.resume = { from: state.pending?.nodeId ?? state.path.at(-1) ?? unitEntryNode, at: new Date().toISOString(), previousStatus, graph: graphMode };
     persistOwnedRun(state, saved!);
   }
   if (options.resumeRunId) debug.log('graph.runs', 'resume', { graphId, runId, from: state.resume?.from, graph: graphMode });
@@ -751,7 +822,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     : baseLog;
   const visits = new Map<string, number>();
   for (const nodeId of state.path) visits.set(nodeId, (visits.get(nodeId) ?? 0) + 1);
-  let current: string | undefined = options.fromNodeId ?? state.pending?.nodeId ?? state.path.at(-1) ?? graph.entryNode;
+  let current: string | undefined = options.fromNodeId ?? state.pending?.nodeId ?? state.path.at(-1) ?? unitEntryNode;
   if (!options.resumeRunId) {
     mkdirSync(dirname(statePath), { recursive: true });
     if (readdirSync(dirname(statePath)).some((file) => file.startsWith(`${runId}.json.`) && file.endsWith('.decision.json'))) {
@@ -788,6 +859,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     }
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
     const command = resolved.command;
+    if (enforceReleaseCommandBindings) assertReleaseCommandBinding(node, command?.command, graph.terminalNodes.includes(current));
     const prompt = resolved.prompt;
     const approval = resolved.approval ? { approval: approvalMessage(resolved.approval.approval, state.input) } : undefined;
     if (resumingPending && (!approval || approval.approval !== state.pending?.message)) {
@@ -837,7 +909,13 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       const redactCredentials = (text: string) => Object.values(credentials).filter(value => value.length > 0)
         .reduce((safe, value) => safe.replaceAll(value, '[REDACTED]'), text);
       const runBash: BashRun = async (body, opts) => {
+        // Hash the actual /bin/bash argv after interpolation. Keep the command text (which may contain
+        // credentials) out of logs, but leave enough to distinguish a replayed publish from npm/docs.
+        const argvSha256 = createHash('sha256').update(JSON.stringify(['/bin/bash', '-c', body])).digest('hex');
+        const fingerprint = { graphId, runId, nodeId: current!, recipe: node.recipe, argvSha256 };
+        debug.log('graph.run', 'command-dispatch', { ...fingerprint, pid: null });
         const execute = options.deps?.runBash ?? realRunBash((pid) => {
+          debug.log('graph.run', 'command-spawn', { ...fingerprint, pid });
           // Publish the child before its start time is known, so a concurrent stop refuses instead of failing
           // the ledger while an untracked node keeps working (REL8b review round 3).
           state.activeNode = { nodeId: current!, pid, pidStartedAt: UNVERIFIED_NODE_START };
@@ -906,7 +984,10 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       const alreadySpent = state.path.length + (state.unitCalls ?? []).reduce((sum, call) => sum + call.steps, 0);
       const remaining = options.unitContext ? options.unitContext.remainingSteps - alreadySpent : Infinity;
       const childRunId = randomUUID();
-      const info = { graphId, runId, nodeId: current, unit: unit.template.graphId, childRunId, parentRunId: runId };
+      const selectedEntry = node.callEntry ?? unit.template.entryNode;
+      const recordEntry = node.callEntry !== undefined || unit.template.unit?.entries !== undefined;
+      const info = { graphId, runId, nodeId: current, unit: unit.template.graphId, childRunId, parentRunId: runId,
+        ...(recordEntry ? { entry: selectedEntry } : {}) };
       let entered = false;
       try {
         for (const key of contract.inputs) if (!Object.hasOwn(inputs, key)) throw new Error(`unit input missing: ${current}.${key}`);
@@ -918,7 +999,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         const child = await runGraph(unit.path, { runId: childRunId, input: inputs, dryRun: false,
           pinChildUniverse: options.pinChildUniverse,
           unitContext: { parentRunId: runId, ancestors: [...(options.unitContext?.ancestors ?? []), graphId],
-            remainingSteps: Math.min(node.budget!.innerSteps, remaining) }, deps: options.deps });
+            remainingSteps: Math.min(node.budget!.innerSteps, remaining),
+            ...(recordEntry ? { entryNodeId: selectedEntry } : {}) }, deps: options.deps });
         const steps = child.path.length + (child.unitCalls ?? []).reduce((sum, call) => sum + call.steps, 0);
         const childExit = child.status === 'done' || child.status === 'failed' ? child.path.at(-1) : undefined;
         // The last successful record carrying every contracted output is the source;
@@ -932,7 +1014,8 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         }, undefined) ?? {};
         state.unitCalls ??= [];
         state.unitCalls.push({ node: current, unit: unit.template.graphId, version: unit.template.version,
-          hash: unit.hash, childRunId, exit: childExit ?? child.status, steps });
+          hash: unit.hash, childRunId, exit: childExit ?? child.status, steps,
+          ...(recordEntry ? { entry: selectedEntry } : {}) });
         if (child.status === 'awaiting-approval') throw new Error(`unit cannot pause for approval: ${current}`);
         if (child.status === 'budget-exceeded' || steps > node.budget!.innerSteps || steps > remaining) {
           debug.log('graph.unit', 'budget-exhausted', { ...info, steps, innerSteps: node.budget!.innerSteps });
@@ -1005,6 +1088,10 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
         startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
     }
+    if (isReleaseLoop && graph.terminalNodes.includes(current) && node.recipe === 'none' &&
+      (exit !== null || output !== undefined || error !== undefined || state.nodes.at(-1)?.executed)) {
+      throw new Error(`release terminal received command output: ${current}`);
+    }
     if (approval) {
       delete state.pending;
       delete state.approvalSourceHash;

package/src/harness/harness-clean.ts

@@ -201,6 +201,8 @@ export function planHarnessClean(input: {
   readWorktreeProvenance?: WorktreeProvenanceReader;
   /** provenance reader가 쓰는 git runner. planner 단독 테스트에서는 반드시 명시한다. */
   run?: GitRunner;
+  /** Allow reclaiming unowned worktrees only for merged-clean branches; default remains preservation. */
+  includeUnownedMergedClean?: boolean;
   /** 조회별 소요 시간(밀리초). 키는 `queryStatus` 조회 칸과 같다. 못 잰 칸은 생략한다. */
   queryTimings?: HarnessCleanQueryTimings;
 }): HarnessCleanPlan {
@@ -353,7 +355,15 @@ export function planHarnessClean(input: {
       continue;
     }
     const ladderReason = `assessment=${assessment.disposition}:${assessment.reason}`;
-    if (assessment.disposition !== 'reclaim-safe' || !ownership.recorded) {
+    const includeUnownedMergedClean = input.includeUnownedMergedClean === true
+      && mode === 'merged'
+      && mergedPr.has(branch)
+      && !openPr.has(branch)
+      && assessment.disposition === 'reclaim-safe'
+      && assessment.reason === 'merged-clean'
+      && !ownership.recorded
+      && ownership.status.startsWith('not-recorded:');
+    if (assessment.disposition !== 'reclaim-safe' || (!ownership.recorded && !includeUnownedMergedClean)) {
       preserve.push({ ...base, reason: `${ladderReason}; ownership=${ownership.status}` });
       continue;
     }
@@ -992,6 +1002,7 @@ export function execHarnessClean(opts: {
   mode: HarnessCleanMode;
   dryRun?: boolean;
   force?: boolean;
+  includeUnownedMergedClean?: boolean;
   branchPrefix?: string;
   repo?: string;
   window?: { offset: number; size: number };
@@ -1087,6 +1098,7 @@ export function execHarnessClean(opts: {
     readWorktreeProvenance: opts.readWorktreeProvenance,
     run,
     mode: opts.mode,
+    ...(opts.includeUnownedMergedClean ? { includeUnownedMergedClean: true } : {}),
     queryStatus,
     queryTimings: {
       worktrees: worktreesTimed.ms,
@@ -1286,10 +1298,16 @@ export function renderHarnessCleanReport(
     item.reason.includes('reclaim-safe:merged-no-worktree'),
   ).length;
   const branchOnlyReclaimedCount = res.plan.remove.filter((item) => item.reason.includes('branch-only')).length;
+  const isUnownedMergedClean = (item: CleanPlanItem): boolean =>
+    item.reason.includes('assessment=reclaim-safe:merged-clean') && item.reason.includes('ownership=not-recorded:');
+  const plannedUnownedMergedCleanCount = res.plan.remove.filter(isUnownedMergedClean).length;
+  const unownedMergedCleanCount = (res.dryRun ? res.plan.remove : res.removed).filter(isUnownedMergedClean).length;
+  const unownedMergedCleanSummary = plannedUnownedMergedCleanCount > 0
+    ? ` · 미소유 merged-clean ${res.dryRun ? '제거 예정' : '회수'} ${unownedMergedCleanCount}` : '';
   L.push(
     omittedPreserve > 0
-      ? `규모 매칭 ${matchedTotal} · 제거 계획 ${res.plan.remove.length} · 보존 ${res.plan.preserve.length} · 화면 ${displayedCount} (보존 ${omittedPreserve}개는 생략) · 브랜치만 회수 ${branchOnlyReclaimedCount} · 워크트리 없이 안전 ${mergedNoWorktreeCount}`
-      : `규모 매칭 ${matchedTotal} · 제거 계획 ${res.plan.remove.length} · 보존 ${res.plan.preserve.length} · 화면 ${displayedCount} · 브랜치만 회수 ${branchOnlyReclaimedCount} · 워크트리 없이 안전 ${mergedNoWorktreeCount}`,
+      ? `규모 매칭 ${matchedTotal} · 제거 계획 ${res.plan.remove.length} · 보존 ${res.plan.preserve.length} · 화면 ${displayedCount} (보존 ${omittedPreserve}개는 생략) · 브랜치만 회수 ${branchOnlyReclaimedCount} · 워크트리 없이 안전 ${mergedNoWorktreeCount}${unownedMergedCleanSummary}`
+      : `규모 매칭 ${matchedTotal} · 제거 계획 ${res.plan.remove.length} · 보존 ${res.plan.preserve.length} · 화면 ${displayedCount} · 브랜치만 회수 ${branchOnlyReclaimedCount} · 워크트리 없이 안전 ${mergedNoWorktreeCount}${unownedMergedCleanSummary}`,
   );
   if (res.plan.remove.length === 0) L.push('정리 대상 없음.');
   else {