elanous 0.2.21 → 0.2.22

package/src/graph-runner/runner.ts

@@ -20,6 +20,7 @@ import { parseGraphTemplateYaml, type GraphEdgeSpec, type GraphNodeSpec, type Gr
 import { createGraphVariant, type GraphVariantPlan } from '../self-implement/graph-variant.js';
 import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
 import { executeBashNode } from '../workflow-runtime/nodes/bash.js';
+import { interpolate } from '../workflow-runtime/variables.js';
 import type { BashNode, NodeExecContext, WorkflowDeps } from '../workflow-runtime/types.js';
 
 type BashRun = WorkflowDeps['runBash'];
@@ -59,6 +60,8 @@ export interface GraphRunState {
 
 export interface GraphRunOptions {
   input?: unknown;
+  /** Bytes already checked by the tick gate, used for a current-graph start or legacy resume. */
+  graphSource?: string;
   dryRun?: boolean;
   variant?: { goal: string; plan: GraphVariantPlan };
   runId?: string;
@@ -72,7 +75,7 @@ export interface GraphRunOptions {
    * its own universe and lands in the tree-derived test universe while the run ledger is prod.
    */
   pinChildUniverse?: boolean;
-  deps?: { root?: string; runBash?: BashRun; log?: (event: string, data: Record<string, unknown>) => void; processStartMs?: (pid: number) => number | null; growthProposer?: GrowthProposer; growthLLM?: (prompt: string) => Promise<string>; classifyGrowthRecipe?: (node: GraphNodeSpec, resolved: { command?: string; approval?: string }) => GrowthRecipeEffect; growthDecision?: GrowthDecisionDeps & { list?: (filters: { status: 'all' }) => DecisionEntry[] } };
+  deps?: { root?: string; runBash?: BashRun; callLLM?: (prompt: string) => Promise<string>; log?: (event: string, data: Record<string, unknown>) => void; beforeNode?: () => void; processStartMs?: (pid: number) => number | null; growthProposer?: GrowthProposer; growthLLM?: (prompt: string) => Promise<string>; classifyGrowthRecipe?: (node: GraphNodeSpec, resolved: { command?: string; approval?: string }) => GrowthRecipeEffect; growthDecision?: GrowthDecisionDeps & { list?: (filters: { status: 'all' }) => DecisionEntry[] } };
 }
 
 function safeSegment(value: string): string {
@@ -83,24 +86,29 @@ function safeSegment(value: string): string {
 }
 
 type CommandRecipe = { command: string; dry_run_command?: string; timeout_ms?: number };
-type Recipe = CommandRecipe | ({ approval: string } & Partial<CommandRecipe>);
+type PromptRecipe = { prompt: string };
+type Recipe = CommandRecipe | PromptRecipe | ({ approval: string } & Partial<CommandRecipe>);
 
 /** 접두 없는 recipe 가 카탈로그 역할이고, 그래프 옆 recipes.yaml 에 같은 키의 `{ command }` 가 있을 때만 cmd 처럼 실행한다. */
 function roleCommand(recipe: string, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): CommandRecipe | undefined {
   if (!recipe || recipe === 'none' || recipe.includes(':') || !catalogRoles.has(recipe)) return undefined;
   const entry = recipes[recipe];
   // An entry that carries an approval only runs through `approval:` — never as a bare command.
-  return entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: entry.command,
+  return entry && 'command' in entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: entry.command,
     ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
     ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } : undefined;
 }
 
-function resolveNodeRecipe(node: GraphNodeSpec, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): { command?: CommandRecipe; approval?: { approval: string } } {
+function resolveNodeRecipe(node: GraphNodeSpec, recipes: Record<string, Recipe>, catalogRoles: ReadonlySet<string>): { command?: CommandRecipe; prompt?: PromptRecipe; approval?: { approval: string } } {
   if (node.recipe === 'none') return {};
+  if (node.kind === 'prompt' && node.recipe.startsWith('prompt:')) {
+    const entry = recipes[node.recipe.slice('prompt:'.length)];
+    return entry && 'prompt' in entry ? { prompt: entry } : {};
+  }
   if (node.recipe.startsWith('cmd:')) {
     const id = node.recipe.slice(4);
     const entry = recipes[id];
-    return entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: { command: entry.command,
+    return entry && 'command' in entry && !('approval' in entry) && typeof entry.command === 'string' ? { command: { command: entry.command,
       ...(entry.dry_run_command ? { dry_run_command: entry.dry_run_command } : {}),
       ...(entry.timeout_ms ? { timeout_ms: entry.timeout_ms } : {}) } } : {};
   }
@@ -133,7 +141,10 @@ function recipesFor(path: string, recipeSource: string): Record<string, Recipe>
   for (const [id, raw] of Object.entries(parsed)) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new Error(`invalid recipe: ${id}`);
     const item = raw as Record<string, unknown>;
-    if (Object.hasOwn(item, 'approval')) {
+    if (Object.hasOwn(item, 'prompt')) {
+      if (typeof item.prompt !== 'string' || !item.prompt.trim() || Object.keys(item).some(key => key !== 'prompt')) throw new Error(`invalid recipe: ${id}`);
+      recipes[id] = { prompt: item.prompt };
+    } else if (Object.hasOwn(item, 'approval')) {
       if (typeof item.approval !== 'string' || !item.approval.trim() ||
         (item.command !== undefined && (typeof item.command !== 'string' || !item.command.trim())) ||
         (item.timeout_ms !== undefined && (!Number.isSafeInteger(item.timeout_ms) || (item.timeout_ms as number) <= 0)) ||
@@ -382,7 +393,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     ? listGraphRuns(root).runs.filter((run) => run.runId === options.resumeRunId && run.graphPath === resolve(path)) : [];
   if (matchingRuns.length > 1) throw new Error(`ambiguous run id: ${options.resumeRunId}`);
   const currentSource = options.resumeRunId && (options.resumeGraphId || matchingRuns.length) && !options.useCurrentGraph
-    ? undefined : readFileSync(path, 'utf8');
+    ? undefined : options.graphSource ?? readFileSync(path, 'utf8');
   const currentHeader: unknown = options.resumeRunId && !options.resumeGraphId && !matchingRuns.length ? parseYaml(currentSource!) : undefined;
   const resumeGraphId = options.resumeGraphId ?? matchingRuns[0]?.graphId ?? (currentHeader && typeof currentHeader === 'object' && !Array.isArray(currentHeader)
     ? (currentHeader as Record<string, unknown>).graph_id : undefined);
@@ -393,7 +404,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   }
   const snapshotDir = saved ? `${saved.statePath}.graph` : undefined;
   const graphMode: 'snapshot' | 'current' = snapshotDir && saved?.graphSnapshot && !options.useCurrentGraph ? 'snapshot' : 'current';
-  const source = graphMode === 'snapshot' ? readFileSync(join(snapshotDir!, 'graph.yaml'), 'utf8') : currentSource ?? readFileSync(path, 'utf8');
+  const source = graphMode === 'snapshot' ? readFileSync(join(snapshotDir!, 'graph.yaml'), 'utf8') : currentSource ?? options.graphSource ?? readFileSync(path, 'utf8');
   // The shared YAML parser requires a recipe string. A command-less node in
   // this runner is represented internally as `none`, without changing that parser.
   const raw: unknown = parseYaml(source);
@@ -451,7 +462,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   for (const node of graph.nodes) {
     if (node.recipe === 'none') continue;
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
-    if (!resolved.command && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
+    if (!resolved.command && !resolved.prompt && !resolved.approval) throw new Error(`unknown command recipe for ${node.nodeId}: ${node.recipe}`);
   }
   const graphId = safeSegment(graph.graphId);
   if (saved && graphId !== saved.graphId) {
@@ -625,6 +636,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     writeFileSync(join(`${statePath}.graph`, 'recipes.yaml'), recipeSource, { flag: 'wx' });
   }
   while (current !== undefined) {
+    options.deps?.beforeNode?.();
     const node = graph.nodes.find((n) => n.nodeId === current);
     if (!node) throw new Error(`undeclared node: ${current}`);
     const resumingPending = state.pending?.nodeId === current;
@@ -643,6 +655,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
     }
     const resolved = resolveNodeRecipe(node, recipes, catalogRoles);
     const command = resolved.command;
+    const prompt = resolved.prompt;
     const approval = resolved.approval ? { approval: approvalMessage(resolved.approval.approval, state.input) } : undefined;
     if (resumingPending && (!approval || approval.approval !== state.pending?.message)) {
       throw new Error(`pending approval no longer matches graph: ${current}`);
@@ -739,6 +752,25 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       error = result.error ? redactCredentials(result.error) : undefined;
       state.executed++;
     }
+    if (prompt && !state.dryRun && !resumingCompleted) {
+      const outputs: Record<string, { ok: boolean; output: unknown; durationMs: number }> = Object.create(null);
+      for (const previous of state.nodes) outputs[previous.nodeId] = { ok: previous.ok, output: lastJsonObject(previous.output) ?? previous.output ?? null, durationMs: 0 };
+      try {
+        const text = interpolate(prompt.prompt, {
+          arguments: typeof state.input === 'string' ? state.input : state.input === undefined ? '' : JSON.stringify(state.input),
+          artifactsDir: dirname(statePath), outputs,
+        });
+        if (text.missing.length) throw new Error(`missing prompt reference: ${text.missing.join(', ')}`);
+        // The LLM is injected only; production wiring to a provider is a follow-up slice.
+        if (!options.deps?.callLLM) throw new Error('prompt node requires an injected LLM (deps.callLLM)');
+        output = await options.deps.callLLM(text.text);
+        ok = true;
+      } catch (cause) {
+        ok = false;
+        error = cause instanceof Error ? cause.message : String(cause);
+      }
+      state.executed++;
+    }
     const seconds = Number(((performance.now() - startedAt) / 1000).toFixed(2));
     // A wall clock stepped back mid-node must not record an end before the start.
     const nodeEndedAt = new Date(Math.max(Date.now(), Date.parse(nodeStartedAt))).toISOString();
@@ -753,7 +785,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       if (approval && !state.dryRun && !command) {
         output = JSON.stringify({ outcome: ok ? 'approved' : 'rejected', ...(state.pending?.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending?.decidedAt ?? null });
       }
-      state.nodes.push({ nodeId: current, ok, exit, executed: !!command && (!state.dryRun || !!command.dry_run_command), ...((command || approval) && (!state.dryRun || !!command?.dry_run_command) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
+      state.nodes.push({ nodeId: current, ok, exit, executed: (!!command && (!state.dryRun || !!command.dry_run_command)) || (!!prompt && !state.dryRun), ...((command || prompt || approval) && (!state.dryRun || !!command?.dry_run_command) && output !== undefined ? { output } : {}), ...(error ? { error } : {}),
         ...(approval && state.pending ? { ...(state.pending.decidedBy === undefined ? {} : { decidedBy: state.pending.decidedBy }), decidedAt: state.pending.decidedAt } : {}),
         startedAt: nodeStartedAt, endedAt: nodeEndedAt, seconds });
     }
@@ -761,7 +793,7 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       delete state.pending;
       delete state.approvalSourceHash;
     }
-    const reported = command && (!state.dryRun || command.dry_run_command) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
+    const reported = (prompt && !state.dryRun) || (command && (!state.dryRun || command.dry_run_command)) ? lastJsonObject(resumingCompleted ? completed?.output : output)?.outcome : undefined;
     const namedOutcome = typeof reported === 'string' ? reported : undefined;
     console.error(`[graph] ${current} ${ok ? 'ok' : 'fail'} (${seconds.toFixed(2)}s)`);
     debug.log('graph.run', 'node', { graphId, runId, nodeId: current, phase: ok ? 'ok' : 'fail', seconds, exit });

package/src/graph-unify/wf-to-graph.ts

@@ -0,0 +1,79 @@
+import { topoSort } from '../workflow-runtime/schema.js';
+import type { DagNode, WorkflowDefinition } from '../workflow-runtime/types.js';
+import type { GraphEdgeSpec, GraphNodeSpec, GraphTemplateSpec } from '../self-implement/graph-yaml.js';
+import { WORKFLOW_CORE_KINDS } from '../graph-kinds/registry.js';
+
+/** In-memory graph projection. The compatibility executor dispatches these
+ * workflow recipes; graph-runner cannot execute all workflow node variants yet. */
+export interface WorkflowGraph {
+  readonly template: GraphTemplateSpec;
+  readonly recipes: Readonly<Record<string, DagNode>>;
+}
+
+export type WorkflowGraphResult =
+  | { readonly ok: true; readonly graph: WorkflowGraph }
+  | { readonly ok: false; readonly reason: string };
+
+/** Project a validated workflow without changing its YAML or executing any work.
+ * Reject constructs whose graph projection would silently change DAG semantics. */
+export function workflowToGraph(workflow: WorkflowDefinition): WorkflowGraphResult {
+  if ((workflow.concurrency ?? 1) !== 1) return { ok: false, reason: 'concurrency > 1' };
+  if (!workflow.nodes.length) return { ok: false, reason: 'empty workflow' };
+  if (workflow.nodes.some(node => node.on_error)) {
+    return { ok: false, reason: 'error routing' };
+  }
+  let order: string[];
+  try { order = topoSort(workflow.nodes); }
+  catch (error) { return { ok: false, reason: String(error) }; }
+  if (order.length !== workflow.nodes.length || new Set(order).size !== order.length) {
+    return { ok: false, reason: 'invalid topology' };
+  }
+  const byId = new Map(workflow.nodes.map(node => [node.id, node] as const));
+  const recipes: Record<string, DagNode> = Object.create(null);
+  const nodes: GraphNodeSpec[] = [];
+  for (const id of order) {
+    const node = byId.get(id)!;
+    const kind = typeof node.kind === 'string' ? node.kind
+      : WORKFLOW_CORE_KINDS.find(key => key !== 'subworkflow' && key in node);
+    if (!kind) {
+      return { ok: false, reason: `unknown node variant: ${id}` };
+    }
+    recipes[id] = node;
+    nodes.push({ nodeId: id, kind, recipe: `workflow:${id}`, maxVisits: 1 });
+  }
+  // A single cursor visits each node exactly once in the same stable topological
+  // order as the serial workflow executor. Preserve original dependencies and
+  // conditions in recipes; do not mistake a when expression for a graph outcome.
+  const edges: GraphEdgeSpec[] = order.slice(1).map((id, index) => ({ from: order[index]!, to: id }));
+  const template: GraphTemplateSpec = {
+    graphId: workflow.name, version: 1, entryNode: order[0]!, terminalNodes: [order.at(-1)!],
+    nodes, edges,
+  };
+  return { ok: true, graph: { template, recipes } };
+}
+
+/** The workflow compatibility cursor follows the projected graph edges, not
+ * the source DAG. The WF event adapter remains the owner of node dispatch. */
+export function walkWorkflowGraph(graph: WorkflowGraph): string[] {
+  const order: string[] = [];
+  const visited = new Set<string>();
+  let current: string | undefined = graph.template.entryNode;
+  while (current !== undefined) {
+    const spec = graph.template.nodes.find(node => node.nodeId === current);
+    if (visited.has(current) || !spec || spec.recipe !== `workflow:${current}` || spec.maxVisits !== 1
+      || !Object.hasOwn(graph.recipes, current)) throw new Error(`invalid workflow graph cursor: ${current}`);
+    const recipe = graph.recipes[current]!;
+    const kind = typeof recipe.kind === 'string' ? recipe.kind
+      : WORKFLOW_CORE_KINDS.find(key => key !== 'subworkflow' && key in recipe);
+    if (recipe.id !== current || kind !== spec.kind) throw new Error(`invalid workflow graph recipe: ${current}`);
+    visited.add(current);
+    order.push(current);
+    const outgoing: GraphEdgeSpec[] = graph.template.edges.filter(edge => edge.from === current);
+    if (outgoing.length > 1 || outgoing.some(edge => edge.to === undefined)) throw new Error(`invalid workflow graph edge: ${current}`);
+    current = outgoing[0]?.to;
+  }
+  if (order.length !== graph.template.nodes.length || !graph.template.terminalNodes.includes(order.at(-1)!)) {
+    throw new Error('incomplete workflow graph path');
+  }
+  return order;
+}

package/src/graph-wizard/generate.ts

@@ -18,6 +18,8 @@ import { validateGraphYaml } from '../nexus/api/graph-kinds.js';
 import { defaultGraphsDir } from '../self-implement/graph-templates.js';
 import { WORKFLOW_SYNTH_SYSTEM_PROMPT } from '../workflow-synth/system-prompt.js';
 import { WIZARD_ARCHETYPES } from './archetypes.js';
+import { listInstalledPacks, queryInstalledPack } from '../knowledge/query.js';
+import { parsePackIdString } from '../knowledge/kgs/pack.js';
 import { WIZARD_MAX_RETRIES, WIZARD_STEPS, WIZARD_STEP_IDS, recipesYamlFor, type WizardNodeStep } from './steps.js';
 
 export interface GraphWizardTurn { role: 'user' | 'assistant'; text: string }
@@ -28,6 +30,8 @@ export interface GraphWizardRequest {
   /** 있으면 prompt 는 «이 그래프를 고치라»는 지시다 — 결과는 고친 «전체» YAML. */
   currentYaml?: string;
   history?: GraphWizardTurn[];
+  /** Installed pack selected for a knowledge (RAG) node. */
+  packId?: string;
 }
 
 export interface GraphWizardResult {
@@ -58,10 +62,18 @@ export interface GraphWizardDeps {
   /** 이미 쓰인 graph_id(핵심 ⊕ 내 그래프). 기본 = graphs/** ⊕ <state>/graphs. */
   existingIds?: () => ReadonlySet<string>;
   maxAttempts?: number;
+  /** Installed pack inventory and retrieval seams for isolated generation. */
+  packs?: typeof listInstalledPacks;
+  searchPack?: typeof queryInstalledPack;
 }
 
 export const GRAPH_WIZARD_MAX_ATTEMPTS = 3;
 
+/** Inventory used by the editor's pack picker and the wizard's validation. */
+export function wizardInstalledPacks(deps: GraphWizardDeps = {}): Array<{ id: string; title: string }> {
+  return (deps.packs ?? listInstalledPacks)();
+}
+
 /** 요청 자체가 틀렸다(400) — LLM 실패(502)와 가른다. */
 export class GraphWizardInputError extends Error { override name = 'GraphWizardInputError'; }
 const GRAPH_ID = /^[a-z0-9-]+$/;
@@ -422,8 +434,9 @@ async function defaultCallLLM(prompt: string): Promise<string> {
 function buildPrompt(input: {
   req: GraphWizardRequest; kind: GraphKind; id: string; base?: TemplateEntry; templates: readonly TemplateEntry[];
   previous?: { yaml: string; issues: string[] };
+  evidence?: string;
 }): string {
-  const { req, kind, id, base, templates, previous } = input;
+  const { req, kind, id, base, templates, previous, evidence } = input;
   const kinds = listNodeKinds(kind).map((k) => k.kind).join(', ');
   const editing = typeof req.currentYaml === 'string' && req.currentYaml.trim() !== '';
   const lines: string[] = [
@@ -451,6 +464,8 @@ function buildPrompt(input: {
   } else {
     lines.push('', `사용자의 말: ${req.prompt}`);
   }
+  if (evidence) lines.push('', '선택한 설치 팩의 검색 근거:', evidence,
+    `지식(RAG) 노드를 cmd 단계로 넣고 # 지식 검색 | knowledge-rag | ${req.packId} 주석을 붙인다. 다음 산출 단계는 이 노드의 근거를 사용한다. 실행 입력 input.query 가 있으면 질문으로 검색하고 없으면 설치 팩 전체 색인에서 가져온다. 근거에 없는 사실을 만들지 마라.`);
   if (previous) {
     lines.push('', '직전 시도가 검증에 실패했다. 아래 문제를 «전부» 고쳐 전체 YAML 을 다시 써라:', ...previous.issues.map((i) => `- ${i}`),
       '직전 YAML:', '```yaml', previous.yaml.trim(), '```');
@@ -467,6 +482,15 @@ export async function generateGraphFromPrompt(req: GraphWizardRequest, deps: Gra
   const kind: GraphKind = req.kind === 'workflow' ? 'workflow' : 'harness';
   const prompt = typeof req.prompt === 'string' ? req.prompt.trim() : '';
   if (!prompt) throw new GraphWizardInputError('prompt is required');
+  if (req.packId !== undefined && kind !== 'harness') throw new GraphWizardInputError('pack selection requires a harness graph');
+  let evidence: string | undefined;
+  if (req.packId !== undefined) {
+    if (!parsePackIdString(req.packId) || !wizardInstalledPacks(deps).some(pack => pack.id === req.packId))
+      throw new GraphWizardInputError(`pack not installed: ${req.packId}`);
+    const cards = (deps.searchPack ?? queryInstalledPack)(req.packId, prompt);
+    if (!cards.length) throw new GraphWizardInputError(`no knowledge found in ${req.packId} for: ${prompt}`);
+    evidence = cards.slice(0, 5).map(card => `[${card.ref}] ${card.title}: ${card.body.slice(0, 1200)}`).join('\n');
+  }
   const editing = typeof req.currentYaml === 'string' && req.currentYaml.trim() !== '';
   const graphsDir = deps.graphsDir ?? defaultGraphsDir();
   const templates = kind === 'harness' ? listWizardTemplates(graphsDir) : [];
@@ -497,7 +521,7 @@ export async function generateGraphFromPrompt(req: GraphWizardRequest, deps: Gra
   for (attempts = 1; attempts <= maxAttempts; attempts += 1) {
     let text: string;
     try {
-      text = await callLLM(buildPrompt({ req: { ...req, prompt }, kind, id, base: keywordBase, templates,
+      text = await callLLM(buildPrompt({ req: { ...req, prompt }, kind, id, base: keywordBase, templates, evidence,
         ...(attempts > 1 ? { previous: { yaml, issues } } : {}) }));
     } catch (error) {
       debug.log('graph.wizard', 'error', { id, kind, attempt: attempts, base, message: error instanceof Error ? error.message : String(error) });
@@ -514,6 +538,14 @@ export async function generateGraphFromPrompt(req: GraphWizardRequest, deps: Gra
     try { issues = validateWizardYaml(kind, yaml); }
     catch (error) { issues = [`검증 실패: ${error instanceof Error ? error.message : String(error)}`]; }
     steps = kind === 'harness' ? parseNodeAnnotations(yaml) : {};
+    if (req.packId && issues.length === 0) {
+      const raw = parseYaml(yaml) as { nodes?: Array<{ node_id: string; recipe: string }>; edges?: Array<{ from: string; map?: Record<string, string> }> };
+      const rag = (raw.nodes ?? []).find(node => node.recipe.startsWith('cmd:') && steps[node.node_id]?.step === 'knowledge-rag' && steps[node.node_id]?.arg === req.packId);
+      if (!rag || !(raw.edges ?? []).some(edge => edge.from === rag.node_id &&
+        typeof edge.map?.ok === 'string' && !['done', 'failed'].includes(edge.map.ok) &&
+        (raw.nodes ?? []).some(node => node.node_id === edge.map!.ok && node.recipe.startsWith('cmd:'))))
+        issues.push(`선택한 팩 ${req.packId} 의 knowledge-rag 노드를 산출 단계에 연결하라`);
+    }
     recipes = undefined;
     dryRun = undefined;
     if (kind === 'harness' && issues.length === 0) {

package/src/graph-wizard/steps.ts

@@ -9,6 +9,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { debug } from '../debug/log.js';
+import { queryInstalledPack } from '../knowledge/query.js';
 
 export interface WizardStepSpec {
   id: string;
@@ -28,6 +29,7 @@ export const WIZARD_STEPS: readonly WizardStepSpec[] = [
   { id: 'notify-me', use: '실패·포기 같은 사건을 나(대표)에게 알린다. arg = 알림 문구', outcomes: ['ok', 'fail'], timeoutMs: 60_000 },
   { id: 'gh-pr-review', use: 'GitHub PR 을 엘라누스 리뷰어로 리뷰한다. arg = PR 번호(없으면 실행 입력 input.pr). 결과 ok(must-fix 없음) · must-fix', outcomes: ['ok', 'must-fix', 'fail'], timeoutMs: 900_000 },
   { id: 'gh-pr-merge', use: 'GitHub PR 을 squash 머지한다. arg = PR 번호(없으면 input.pr)', outcomes: ['ok', 'fail'], timeoutMs: 300_000 },
+  { id: 'knowledge-rag', use: '설치된 지식 팩만 검색해 인용 가능한 근거를 낸다. arg = pack:<slug>@<version>; 실행 입력 input.query 또는 앞 단계 결과로 검색하며 둘 다 없으면 팩의 색인에서 가져온다', outcomes: ['ok', 'fail'], timeoutMs: 120_000 },
   { id: 'custom', use: '위 단계로 안 되는 외부 연동(노션·슬랙 업로드 등). 실행하면 «아직 구현되지 않음»으로 실패한다. arg = 무엇을 해야 하는지', outcomes: ['ok', 'fail'], timeoutMs: 60_000 },
 ];
 
@@ -140,6 +142,17 @@ export function runWizardStep(step: string, arg: string | undefined, ctx: GraphC
   const started = Date.now();
   let result: StepResult;
   switch (step) {
+    case 'knowledge-rag': {
+      const query = ctx.input && typeof ctx.input === 'object' && typeof (ctx.input as { query?: unknown }).query === 'string'
+        ? (ctx.input as { query: string }).query : prev.trim();
+      if (!arg) { result = { outcome: 'fail', error: 'knowledge-rag: pack id(arg) required' }; break; }
+      try {
+        const hits = queryInstalledPack(arg, query);
+        result = hits.length ? { outcome: 'ok', text: hits.slice(0, 5).map(hit => `[${hit.ref}] ${hit.title}: ${hit.body}`).join('\n') }
+          : { outcome: 'fail', error: `knowledge-rag: no matches in ${arg}` };
+      } catch (error) { result = { outcome: 'fail', error: error instanceof Error ? error.message : String(error) }; }
+      break;
+    }
     case 'web-search': {
       const query = arg?.trim() || (ctx.input && typeof ctx.input === 'object' && typeof (ctx.input as { query?: unknown }).query === 'string' ? (ctx.input as { query: string }).query : '');
       if (!query) { result = { outcome: 'fail', error: 'web-search: 검색어(arg)가 없다' }; break; }

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

@@ -1,4 +1,4 @@
-import { execFile, execFileSync, spawn } from 'node:child_process';
+import { execFile, execFileSync, spawn, spawnSync } from 'node:child_process';
 import { promisify } from 'node:util';
 import { dlopen, FFIType } from 'bun:ffi';
 import { createHash } from 'node:crypto';
@@ -10,6 +10,7 @@ import { LogStore, logsDbPath } from '../mss/logging/log-store.js';
 import { loadSelfDevRun } from '../self-dev/run-store.js';
 import { normalizeRunId } from './harness-space.js';
 import { effectiveInstanceRoot, prodInstanceRoot } from '../instance/resolve.js';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { lookupGoal, type GoalLookupOptions, type GoalLookupResult } from '../self-implement/goal-lookup.js';
 import { archiveGoals, type GoalArchiveOptions } from '../self-implement/goal-archive.js';
 import { detectBursts, formatIncidentBurstWarning, incidentLastLines, readRunExits, recentBurst, recordRunExit } from './harness-incidents.js';
@@ -23,13 +24,15 @@ import { resolveChildLlmEffort, resolveImplementationChildModel } from '../self-
 import { resolveHarnessTarget } from '../self-implement/harness-target-options.js';
 import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
-import { collectDraftMetrics, DRAFT_SWEEP_CONCURRENCY, mapBounded, runDraftSweep, sweepFailureReason, type DraftSweepAdapters, type DraftSweepResult, type SweepDraft, type SweepMergedPr, type SweepReviewGate } from '../self-dev/draft-sweep.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';
 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 { 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 { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDeps } from './deliverable-verify-cli.js';
@@ -1589,6 +1592,28 @@ function readProcessCwd(pid: number): Pick<HarnessProcessRecord, 'cwd' | 'cwdSta
   }
 }
 
+/** One `lsof` for many pids (a per-pid lsof costs ~0.1–0.3 s); lsof exits 1 when some pid is gone yet prints the rest. */
+function batchProcessCwdReader(pids: readonly number[]): (pid: number) => Pick<HarnessProcessRecord, 'cwd' | 'cwdStatus' | 'cwdFailureReason'> {
+  const cwds = new Map<number, string>();
+  let failure: string | undefined;
+  if (pids.length) {
+    const result = spawnSync('lsof', ['-a', '-d', 'cwd', '-Fpn', '-p', pids.join(',')],
+      { encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024, stdio: ['ignore', 'pipe', 'ignore'] });
+    if (result.error || typeof result.stdout !== 'string') failure = observationFailureReason(result.error ?? new Error('lsof output missing'));
+    else {
+      let current: number | undefined;
+      for (const line of result.stdout.split('\n')) {
+        if (line.startsWith('p')) current = Number(line.slice(1));
+        else if (line.startsWith('n') && current !== undefined && line.length > 1) cwds.set(current, line.slice(1).trim());
+      }
+    }
+  }
+  return (pid) => {
+    const cwd = cwds.get(pid);
+    return cwd ? { cwd, cwdStatus: 'observed' } : { cwdStatus: 'unknown', cwdFailureReason: failure ?? 'lsof cwd missing' };
+  };
+}
+
 const OWNERSHIP_ENV_KEYS = new Set<string>(Object.values(HARNESS_PROCESS_OWNERSHIP_ENV));
 
 function ownershipValueFromEntry(entry: string, key: string): string | undefined {
@@ -1744,10 +1769,23 @@ export function readProcessOwnership(
   }
 }
 
-export function defaultListHarnessProcesses(): HarnessProcessListObservation {
+/** Narrows the per-process reads (`lsof` cwd ≈ 0.1 s each · `ps eww`) of `defaultListHarnessProcesses`. */
+export interface HarnessProcessListOptions {
+  /** Keep only matching records; the others are dropped before any per-process read. */
+  readonly include?: (record: HarnessProcessRecord) => boolean;
+  /** Skip the ownership (`ps eww`) read — for callers that only need the cwd. */
+  readonly cwdOnly?: boolean;
+  /** Wall-clock budget for the per-process reads; records past it keep `cwdStatus: 'unknown'` (reason names the budget). */
+  readonly deadlineMs?: number;
+  readonly readCwd?: (pid: number) => Pick<HarnessProcessRecord, 'cwd' | 'cwdStatus' | 'cwdFailureReason'>;
+  readonly psOutput?: () => string;
+  readonly clock?: () => number;
+}
+
+export function defaultListHarnessProcesses(options: HarnessProcessListOptions = {}): HarnessProcessListObservation {
   let out: string;
   try {
-    out = execFileSync('ps', ['-axo', 'pid=,ppid=,pcpu=,etime=,command='], {
+    out = options.psOutput ? options.psOutput() : execFileSync('ps', ['-axo', 'pid=,ppid=,pcpu=,etime=,command='], {
       encoding: 'utf8',
       timeout: 5_000,
       stdio: ['ignore', 'pipe', 'ignore'],
@@ -1757,11 +1795,21 @@ export function defaultListHarnessProcesses(): HarnessProcessListObservation {
   }
   const parsed = parseHarnessProcessPsOutput(out);
   if (parsed.status === 'failed') return parsed;
-  const records = parsed.records.map((record) => ({
-    ...record,
-    ...readProcessCwd(record.pid),
-    ownership: readProcessOwnership(record.pid),
-  }));
+  const clock = options.clock ?? Date.now;
+  const selected = options.include ? parsed.records.filter(options.include) : parsed.records;
+  const readCwd = options.readCwd ?? (options.cwdOnly ? batchProcessCwdReader(selected.map((record) => record.pid)) : readProcessCwd);
+  const deadline = options.deadlineMs === undefined ? Infinity : clock() + options.deadlineMs;
+  const records = selected.map((record) => {
+    // A host with hundreds of harness processes made the serial reads take minutes (10-08 queue tick hang).
+    if (clock() >= deadline) {
+      return { ...record, cwdStatus: 'unknown' as const, cwdFailureReason: `observation deadline ${options.deadlineMs}ms exceeded` };
+    }
+    return {
+      ...record,
+      ...readCwd(record.pid),
+      ...(options.cwdOnly ? {} : { ownership: readProcessOwnership(record.pid) }),
+    };
+  });
   if (parsed.status === 'incomplete') {
     return {
       status: 'incomplete',
@@ -1877,12 +1925,30 @@ type GithubPull = {
 
 type GhExecute = (args: string[]) => string;
 
-// ⛔ `env: process.env` is required: Bun resolves the executable against the PATH it started with, not the one
-//    ensure-bin-path augments. Under cron's minimal PATH the hourly sweep died with «Executable not found: gh» (2026-09-28).
-const executeGh: GhExecute = (args) => execFileSync('gh', args, {
-  encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024,
-  stdio: ['ignore', 'pipe', 'pipe'], env: process.env,
-});
+// Explicit env preserves the augmented PATH under Bun (cron may start with a minimal PATH).
+// Authentication comes from the same automation policy used by the PR manager, not the user's keyring.
+// Failure details are bounded and redact the token before reaching the sweep result or debug log.
+function ghFailure(args: string[], error: unknown, token: string | undefined): Error {
+  const failure = error as { status?: number | null; code?: number | string; stderr?: string | Buffer };
+  const exit = failure.status ?? (typeof failure.code === 'number' ? failure.code : 'unknown');
+  const stderr = String(failure.stderr ?? '');
+  const stderrTail = (token ? stderr.replaceAll(token, '[REDACTED]') : stderr).slice(-300).replace(/[\r\n]+/g, ' ').trim();
+  try { debug.log('harness.drafts', 'gh-failed', { args0: args[0], exit, stderrTail }); }
+  catch { /* Logging must not hide the gh failure. */ }
+  // gh never ran (e.g. «Executable not found: gh»): no exit or stderr to report, so keep the spawn error itself.
+  if (typeof failure.status !== 'number' && !stderrTail && error instanceof Error) return error;
+  return new Error(`gh ${args.slice(0, 2).join(' ')} exit=${exit}: ${stderrTail}`);
+}
+
+const executeGh: GhExecute = (args) => {
+  const env = ghAutomationEnv(process.env);
+  try {
+    return execFileSync('gh', args, {
+      encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'], env,
+    });
+  } catch (error) { throw ghFailure(args, error, env.GH_TOKEN); }
+};
 
 /** Merge-time adapter: reuse the sweep's GitHub inventory and worktree liveness without a second triage implementation. */
 export async function supersedeMergedGoalDrafts(
@@ -1986,9 +2052,14 @@ function deliverResyncMemo(spaceId: string, memo: ControlMemoPayload,
 }
 
 const execFileAsync = promisify(execFile);
-const executeGhAsync = async (args: string[]): Promise<string> => (await execFileAsync('gh', args, {
-  encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024, env: process.env,
-})).stdout;
+const executeGhAsync = async (args: string[]): Promise<string> => {
+  const env = ghAutomationEnv(process.env);
+  try {
+    return (await execFileAsync('gh', args, {
+      encoding: 'utf8', timeout: 30_000, maxBuffer: 16 * 1024 * 1024, env,
+    })).stdout;
+  } catch (error) { throw ghFailure(args, error, env.GH_TOKEN); }
+};
 
 /** RUN-TTL adapters: open self-impl PRs, head commit time (async, bounded by the core), owning run, memo, label. */
 export async function githubRunTtlAdapters(repository: string, execute: GhExecute = executeGh,
@@ -2467,12 +2538,16 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
 
 export interface HarnessDraftSweepDeps {
   readonly adapters?: DraftSweepAdapters;
+  /** Optional overlap source injection; tests do not read GitHub or logs.db. */
+  readonly overlapAdapters?: OverlapMetricAdapters;
   readonly repository?: () => string;
   readonly write?: (line: string) => void;
   readonly execute?: GhExecute;
   readonly now?: () => Date;
   /** RUN-TTL step adapters. Omitted with injected `adapters` ⇒ the step is skipped (fakes never reach real gh). */
   readonly runTtl?: RunTtlAdapters;
+  /** Test seam for `tools.selfImplement.draftSweepCloseCap`; omitted ⇒ the user config. */
+  readonly closeCapConfig?: () => unknown;
 }
 
 /** RUN-TTL step inside the draft sweep — fail-soft: its failure never changes the sweep verdict. */
@@ -2566,10 +2641,22 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
         const repository = resolveRepositoryName({ repo: opts.repo ?? deps.repository?.(), executeGh: (args) => execute(args) });
         if (!DRAFT_SWEEP_REPOSITORY.test(repository) || repository.includes('..')) throw new HarnessCliInputError(`invalid --repo (expected owner/name): ${repository}`);
         const started = Date.now();
-        const metrics = await collectDraftMetrics(repository, deps.adapters ?? githubDraftSweepAdapters(deps.execute), deps.now?.() ?? new Date());
+        const adapters = deps.adapters ?? githubDraftSweepAdapters(deps.execute);
+        const now = deps.now?.() ?? new Date();
+        const metrics = await collectDraftMetrics(repository, adapters, now);
+        let overlap: Awaited<ReturnType<typeof collectOverlapMetrics>> | null = null;
+        try {
+          overlap = await collectOverlapMetrics(repository, deps.overlapAdapters ?? {
+            ...adapters,
+            listPreflightRows: readAskPreflightRowsSince,
+            listSalvagedRows: readSalvagedRowsSince,
+          }, now);
+        } catch (error) {
+          try { debug.log('self-dev.draft-metrics', 'overlap-failed', { repository, reason: sweepFailureReason(error) }); } catch { /* fail-soft */ }
+        }
         try { debug.log('self-dev.draft-metrics', 'collected', { repository, ms: Date.now() - started, ...metrics }); } catch { /* fail-soft */ }
         const write = deps.write ?? console.log;
-        if (opts.json) write(JSON.stringify({ repository, ...metrics }));
+        if (opts.json) write(JSON.stringify({ repository, ...metrics, overlap }));
         else write(`draft 재고 ${metrics.inventory} · 최장 나이 ${metrics.oldestAgeHours === null ? '해당 없음' : `${metrics.oldestAgeHours.toFixed(1)}h`} · needs-owner ${metrics.needsOwner} · 48h 전환율 ${metrics.conversion48h === null ? '표본 없음' : `${(metrics.conversion48h * 100).toFixed(1)}% (${metrics.converted48h}/${metrics.cohort48h})`}`);
       } catch (error) {
         console.error(humanErrorLine(error));
@@ -2580,7 +2667,8 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
     .option('--apply', '판정한 라벨 변경과 종료를 적용')
     .option('--json', '판정 결과를 JSON 으로 출력')
     .option('--repo <owner/name>', '조회할 GitHub 저장소')
-    .action(async (opts: { apply?: boolean; json?: boolean; repo?: string }) => {
+    .option('--close-cap <n>', '이번 틱 최대 종료 수 (1~100 · config tools.selfImplement.draftSweepCloseCap 보다 우선 · 기본 10)')
+    .action(async (opts: { apply?: boolean; json?: boolean; repo?: string; closeCap?: string }) => {
       try {
         const write = deps.write ?? console.log;
         const execute = deps.execute ?? executeGh;
@@ -2593,7 +2681,16 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
         }
         // One adapter instance per sweep: its open listing and ledger scan are shared with the RUN-TTL step.
         const github = deps.adapters ? undefined : githubDraftSweepAdapters(deps.execute);
-        const result: DraftSweepResult = await runDraftSweep({ repository, apply: opts.apply === true, adapters: deps.adapters ?? github! });
+        const configCap = deps.closeCapConfig
+          ? deps.closeCapConfig()
+          : (() => { try { return getUserConfig().tools?.selfImplement?.draftSweepCloseCap; } catch { return undefined; } })();
+        const cap = resolveDraftSweepCloseCap({ flag: opts.closeCap, config: configCap });
+        for (const warning of cap.warnings) {
+          console.error(`⚠ ${warning}`);
+          try { debug.log('self-dev.draft-sweep', 'close-cap-rejected', { warning, closeCap: cap.closeCap, closeCapSource: cap.closeCapSource }); } catch { /* fail-soft */ }
+        }
+        const result: DraftSweepResult = await runDraftSweep({ repository, apply: opts.apply === true, adapters: deps.adapters ?? github!,
+          closeCap: cap.closeCap, closeCapSource: cap.closeCapSource });
         const reason = result.error ? sweepFailureReason(result.error) : undefined;
         const ttlStarted = Date.now();
         const runTtl = await draftSweepRunTtl(repository, deps, github);
@@ -2944,7 +3041,8 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
       harnessQueueReceiptPath(root, item.launchId!), queueDeps.launchCommand ?? join(import.meta.dir, '../../bin/elanous.mjs'),
       ...(resolve(root) === prodInstanceRoot() ? [] : [`--test=${root}`]), ...args], {
       cwd: item.launchCwd ?? resolve(import.meta.dir, '../..'), stdio: 'inherit',
-      env: { ...process.env, ELANOUS_STATE_DIR: root, ELANOUS_HARNESS_SEAT: item.seat,
+      env: { ...process.env, ELANOUS_STATE_DIR: root,
+        ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(root), ELANOUS_HARNESS_SEAT: item.seat,
         ELANOUS_HARNESS_QUEUE_LAUNCH: item.launchId! },
     });
     // Capture the end at spawn time: a child that already closed (or died by a signal) must not leave the parent waiting.