elanous 0.2.4 → 0.2.5

package/src/execution-loop/gates.ts

@@ -0,0 +1,197 @@
+import type { TaskCard } from '../task-cards/card-store.js';
+import { decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
+import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from '../harness/harness-substrate-default.js';
+import { podMemoryLimitFor } from '../task-orchestrator/surfaces/self-implement-pod.js';
+import { recallMemoryContext } from '../agent-substrate/execution/memory-context.js';
+
+export interface GateResult<T> {
+  decision: T;
+  explanation: string;
+}
+
+export interface BudgetGateDeps {
+  readInputs: () => Promise<BudgetInputs>;
+  decide: (inputs: BudgetInputs) => BudgetDecision;
+}
+
+/** Observe the existing quota decision; callers record it, not apply it to the launch. */
+export async function budgetGate(
+  deps: BudgetGateDeps = { readInputs: readBudgetInputsLive, decide: decideBudget },
+): Promise<GateResult<BudgetDecision>> {
+  const decision = deps.decide(await deps.readInputs());
+  return { decision, explanation: decision.reasons.join(' · ') || `budget: ${decision.action}` };
+}
+
+export interface PlacementGateInput {
+  goal: string;
+  /** A local-only capability or file is an observation, not a reason to probe a remote pool. */
+  needsBrowser?: boolean;
+  needsVideo?: boolean;
+  needsAppSigning?: boolean;
+  localFiles?: readonly string[];
+  flag?: { substrate?: 'pod' | 'local'; podPool?: string };
+}
+
+export interface PlacementGateDeps {
+  resolveSubstrate: (input: { flag?: { substrate?: 'pod' | 'local'; podPool?: string } }) => ResolvedHarnessSubstrate;
+  memoryLimit: (goal: string) => { limit: string; tier: string; source: string };
+}
+
+export type PlacementDecision = (ResolvedHarnessSubstrate | {
+  substrate: 'unknown';
+  pool: null;
+  source: 'unknown';
+}) & {
+  /** Reachability is deliberately not probed by this observational gate. */
+  poolReachability: 'unknown' | 'not-applicable';
+  memory?: { limit: string; tier: string; source: string };
+  localReasons: string[];
+  /** Omitted observations must not be silently treated as negative evidence. */
+  unknownInputs: string[];
+};
+
+const defaultPlacementDeps: PlacementGateDeps = {
+  resolveSubstrate: ({ flag }) => resolveHarnessSubstrate({ flag, env: process.env, currentContext: () => undefined }),
+  memoryLimit: (goal) => podMemoryLimitFor(goal, process.env),
+};
+
+export function placementGate(
+  input: PlacementGateInput,
+  deps: PlacementGateDeps = defaultPlacementDeps,
+): GateResult<PlacementDecision> {
+  const unknownInputs = [
+    ...(input.needsBrowser === undefined ? ['needsBrowser'] : []),
+    ...(input.needsVideo === undefined ? ['needsVideo'] : []),
+    ...(input.needsAppSigning === undefined ? ['needsAppSigning'] : []),
+    ...(input.localFiles === undefined ? ['localFiles'] : []),
+    ...(input.flag?.substrate === undefined ? ['substrate'] : []),
+  ];
+  const localReasons = [
+    ...(input.needsBrowser ? ['browser'] : []),
+    ...(input.needsVideo ? ['video'] : []),
+    ...(input.needsAppSigning ? ['app signing'] : []),
+    ...(input.localFiles?.length ? [`local files: ${input.localFiles.join(', ')}`] : []),
+  ];
+  // A measured local-only need wins; otherwise unknown needs cannot justify a remote assertion.
+  if (!localReasons.length && input.flag?.substrate !== 'local' && unknownInputs.length) {
+    return {
+      decision: { substrate: 'unknown', pool: null, source: 'unknown', poolReachability: 'unknown', localReasons, unknownInputs },
+      explanation: `placement=unknown; unmeasured=${unknownInputs.join(', ')}; pool reachability not checked`,
+    };
+  }
+  const flag = localReasons.length ? { substrate: 'local' as const } : input.flag;
+  let resolved: ResolvedHarnessSubstrate;
+  try {
+    resolved = deps.resolveSubstrate({ flag });
+  } catch (error) {
+    if (flag?.substrate !== 'pod' || !(error instanceof Error) || !error.message.includes('Pod 풀 또는 현재 컨텍스트에 닿지 못했다')) throw error;
+    // No configured pool is not evidence that a remote pool is unreachable.
+    resolved = { substrate: 'pod', pool: null, source: 'flag' };
+  }
+  const poolReachability = resolved.substrate === 'pod' ? 'unknown' : 'not-applicable';
+  const memory = resolved.substrate === 'pod' ? deps.memoryLimit(input.goal) : undefined;
+  const decision: PlacementDecision = {
+    ...resolved, poolReachability, localReasons, unknownInputs,
+    ...(memory ? { memory } : {}),
+  };
+  return {
+    decision,
+    explanation: (resolved.substrate === 'local'
+      ? `local: ${localReasons.join(' · ') || `substrate ${resolved.source}`}`
+      : `pod: pool=${resolved.pool ?? 'unknown'}; reachability=unknown (not checked); memory=${memory?.tier ?? 'unknown'} (${memory?.limit ?? 'unknown'})`)
+      + (unknownInputs.length ? `; unmeasured=${unknownInputs.join(', ')}` : ''),
+  };
+}
+
+export interface RelationGateDeps {
+  openCards: () => Promise<readonly TaskCard[]> | readonly TaskCard[];
+  /** A previous completed run is reported as a fact, never inferred from a matching title. */
+  priorTermination: (goalId: string) => Promise<string | undefined> | string | undefined;
+  /** 'unknown' = the caller cannot observe running runs; recorded as unknown, never as none. */
+  activeRuns: (goalId: string) => Promise<readonly string[] | 'unknown'> | readonly string[] | 'unknown';
+  /** Optional preflight overlap observations are kept separate from open-card overlap. */
+  preflightOverlaps?: (paths: readonly string[]) => Promise<readonly string[]> | readonly string[];
+  dependsOn?: (goalId: string) => Promise<readonly string[]> | readonly string[];
+  similarCards?: (card: TaskCard, openCards: readonly TaskCard[]) => Promise<readonly string[]> | readonly string[];
+}
+
+export interface RelationDecision {
+  overlappingCards: string[];
+  preflightOverlaps: string[] | 'unknown';
+  dependsOn: string[] | 'unknown';
+  similarCards: string[] | 'unknown';
+  sameGoalActiveRuns: string[] | 'unknown';
+  priorTermination?: string;
+  /** Overlaps and similarity are observations, not dispatch locks. */
+  action: 'record';
+}
+
+export async function relationGate(
+  card: TaskCard,
+  targetPaths: readonly string[],
+  deps: RelationGateDeps,
+): Promise<GateResult<RelationDecision>> {
+  const [cards, priorTermination, sameGoalActiveRuns] = await Promise.all([
+    deps.openCards(), deps.priorTermination(card.goalId), deps.activeRuns(card.goalId),
+  ]);
+  const [preflightOverlaps, dependsOn, similarCards] = await Promise.all([
+    deps.preflightOverlaps?.(targetPaths) ?? 'unknown',
+    deps.dependsOn?.(card.goalId) ?? 'unknown',
+    deps.similarCards?.(card, cards) ?? 'unknown',
+  ]);
+  const target = new Set(targetPaths);
+  const overlappingCards = cards
+    .filter((other) => other.id !== card.id && other.status === 'open' && other.sections.some((section) => {
+      if (!section.key.startsWith('workspace')) return false;
+      try {
+        const workspace = JSON.parse(section.content) as { targetPaths?: unknown; paths?: unknown };
+        const paths = workspace.targetPaths ?? workspace.paths;
+        return Array.isArray(paths) && paths.some((path) => typeof path === 'string' && target.has(path));
+      } catch { return false; }
+    }))
+    .map((other) => other.id);
+  const observed = (value: readonly string[] | string): string =>
+    typeof value === 'string' ? value : value.join(',') || 'none';
+  const decision: RelationDecision = {
+    action: 'record', overlappingCards,
+    preflightOverlaps: preflightOverlaps === 'unknown' ? 'unknown' : [...preflightOverlaps],
+    dependsOn: dependsOn === 'unknown' ? 'unknown' : [...dependsOn],
+    similarCards: similarCards === 'unknown' ? 'unknown' : [...similarCards],
+    sameGoalActiveRuns: sameGoalActiveRuns === 'unknown' ? 'unknown' : [...sameGoalActiveRuns],
+    ...(priorTermination === undefined ? {} : { priorTermination }),
+  };
+  return {
+    decision,
+    explanation: `overlap=${observed(overlappingCards)}; preflight=${observed(preflightOverlaps)}; dependsOn=${observed(dependsOn)}; similar=${observed(similarCards)}; active=${observed(sameGoalActiveRuns)}; prior=${priorTermination ?? 'unknown'}; overlaps do not block launch`,
+  };
+}
+
+export interface MemoryGateDeps {
+  recall: (query: string) => Promise<string>;
+  priorAbandonment: (goalId: string) => Promise<string | undefined> | string | undefined;
+}
+
+export interface MemoryDecision {
+  context: string;
+  priorAbandonment?: string;
+  /** The existing recall API returns formatted context, not stable fragment IDs. */
+  fragmentIds: string[];
+  action: 'record';
+}
+
+export async function memoryGate(
+  card: Pick<TaskCard, 'goalId' | 'title'>,
+  deps: MemoryGateDeps = { recall: recallMemoryContext, priorAbandonment: () => undefined },
+): Promise<GateResult<MemoryDecision>> {
+  const [context, priorAbandonment] = await Promise.all([
+    deps.recall(card.title), deps.priorAbandonment(card.goalId),
+  ]);
+  const decision: MemoryDecision = {
+    action: 'record', context, fragmentIds: [],
+    ...(priorAbandonment === undefined ? {} : { priorAbandonment }),
+  };
+  return {
+    decision,
+    explanation: `memory=${context ? 'recalled' : 'none or unavailable'}; prior abandonment=${priorAbandonment ?? 'unknown'}; fragment IDs unavailable from recall API`,
+  };
+}

package/src/graph-kinds/installed-plugin-nodes.ts

@@ -0,0 +1,95 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, realpathSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
+import { listInstalledPlugins, type InstalledPlugin } from '../plugins/install/plugin-install.js';
+import { loadPluginManifestFromDir, type PluginManifest } from '../plugins/core/manifest.js';
+import { loadPluginNodes } from './plugin-nodes.js';
+import { getNodeKindRegistration, listNodeKinds, unregisterPluginNodeKind, type GraphKind, type NodeKindEntry } from './registry.js';
+
+export interface InstalledPluginNodeSyncResult {
+  registered: number;
+  removed: number;
+  errors: Array<{ plugin: string; reason: string }>;
+}
+
+type OwnedNode = { graph: GraphKind; kind: string; plugin: string; registered: NodeKindEntry };
+type InstalledNodeState = { stamp: string; owned: Map<string, { fingerprint: string; nodes: OwnedNode[] }> };
+const states = new Map<string, InstalledNodeState>();
+
+function fingerprint(item: InstalledPlugin, manifest: PluginManifest): string {
+  const root = realpathSync(item.path);
+  const hash = createHash('sha256');
+  hash.update(JSON.stringify([item.name, item.version, item.market, item.sha256, item.installedAt, manifest]));
+  for (const path of manifest.contributes.nodes ?? []) {
+    const file = realpathSync(resolve(root, path));
+    const rel = relative(root, file);
+    if (!path.startsWith('./') || !rel || rel === '..' || rel.startsWith('../') || isAbsolute(rel)) {
+      throw new Error(`node path must remain inside the plugin dir: ${path}`);
+    }
+    hash.update(path);
+    hash.update(readFileSync(file));
+  }
+  return hash.digest('hex');
+}
+
+/** Reconcile only registrations made by this sync; the registry's identity check protects other owners. */
+export function syncInstalledPluginNodes(root: string): InstalledPluginNodeSyncResult {
+  const result: InstalledPluginNodeSyncResult = { registered: 0, removed: 0, errors: [] };
+  const stateRoot = resolve(root);
+  const ledger = statSync(join(stateRoot, 'plugins', 'installed.json'), { throwIfNoEntry: false, bigint: true });
+  // The installer atomically replaces the ledger, so mtime and size alone can
+  // coincide across installs. File identity and ctime detect that replacement.
+  const stamp = ledger ? `${ledger.dev}:${ledger.ino}:${ledger.ctimeNs}:${ledger.mtimeNs}:${ledger.size}` : 'missing';
+  const previous = states.get(stateRoot);
+  if (previous?.stamp === stamp) return result;
+
+  // The installer commits a new ledger via rename after the package directory is in place.
+  // If discovery itself fails, the stamp is not advanced and the next request retries.
+  const installed = listInstalledPlugins(stateRoot);
+  const current = new Set(installed.map(item => item.path));
+  const owned = previous?.owned ?? new Map<string, { fingerprint: string; nodes: OwnedNode[] }>();
+  const removeOwned = (path: string): void => {
+    for (const node of owned.get(path)?.nodes ?? []) {
+      if (unregisterPluginNodeKind(node.graph, node.kind, node.plugin, node.registered)) result.removed++;
+    }
+    owned.delete(path);
+  };
+  for (const path of owned.keys()) {
+    if (!current.has(path)) removeOwned(path);
+  }
+
+  for (const item of installed) {
+    try {
+      const manifest = loadPluginManifestFromDir(item.path, { id: item.name }).manifest;
+      if (!manifest.contributes.nodes?.length) {
+        removeOwned(item.path);
+        continue;
+      }
+      const version = fingerprint(item, manifest);
+      if (owned.get(item.path)?.fingerprint === version) continue;
+      removeOwned(item.path);
+      const before = new Set(listNodeKinds().filter(entry => entry.plugin === manifest.id).map(entry => `${entry.graph}:${entry.kind}`));
+      const loaded = loadPluginNodes(item.path, manifest);
+      const nodes: OwnedNode[] = [];
+      for (const entry of listNodeKinds().filter(entry => entry.plugin === manifest.id && !before.has(`${entry.graph}:${entry.kind}`))) {
+        const registered = getNodeKindRegistration(entry.graph, entry.kind);
+        if (registered) nodes.push({ graph: entry.graph, kind: entry.kind, plugin: manifest.id, registered });
+      }
+      if (loaded.errors.length) {
+        for (const node of nodes) unregisterPluginNodeKind(node.graph, node.kind, node.plugin, node.registered);
+        result.errors.push({ plugin: item.name, reason: loaded.errors.join('; ') });
+        owned.set(item.path, { fingerprint: version, nodes: [] });
+        continue;
+      }
+      result.registered += nodes.length;
+      owned.set(item.path, { fingerprint: version, nodes });
+    } catch (error) {
+      removeOwned(item.path);
+      result.errors.push({ plugin: item.name, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  states.set(stateRoot, { stamp, owned });
+  debug.log('graph.kinds', 'installed-sync', { root: stateRoot, ...result });
+  return result;
+}

package/src/graph-kinds/plugin-nodes.ts

@@ -34,8 +34,16 @@ export function loadPluginNodes(pluginDir: string, manifest: PluginManifest): Pl
       if (node.graph === 'workflow') {
         if (!node.run || typeof node.run !== 'object' || Array.isArray(node.run)) throw new Error('run must be an object');
         const spec = node.run as Record<string, unknown>;
-        if (Object.keys(spec).length !== 1 || !['bash', 'http', 'skill'].some((key) => key in spec)) {
-          throw new Error('run must contain exactly one bash, http or skill executor');
+        if (Object.keys(spec).length !== 1 || !['bash', 'http', 'skill', 'mcp'].some((key) => key in spec)) {
+          throw new Error('run must contain exactly one bash, http, skill or mcp executor');
+        }
+        if ('mcp' in spec) {
+          const mcp = spec.mcp;
+          if (!mcp || typeof mcp !== 'object' || Array.isArray(mcp)
+            || typeof (mcp as Record<string, unknown>).server !== 'string'
+            || typeof (mcp as Record<string, unknown>).tool !== 'string') {
+            throw new Error('mcp run requires server and tool');
+          }
         }
         run = spec as NodeKindRun;
       } else if (node.run !== undefined) {

package/src/graph-runner/runner.ts

@@ -1,9 +1,13 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { execFile } from 'node:child_process';
-import { linkSync, mkdirSync, readFileSync, readdirSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { existsSync, linkSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve, sep } from 'node:path';
 import { parse as parseYaml, stringify as stringifyYaml } from 'yaml';
+import { getElanousConfigDir, getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { debug } from '../debug/log.js';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { listInstalledPlugins } from '../plugins/install/plugin-install.js';
+import { credentialStatus, pluginEnv } from '../plugins/install/plugin-credentials.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { loadNodeCatalog } from '../self-implement/graph-catalog.js';
 import { parseGraphTemplateYaml, type GraphEdgeSpec, type GraphNodeSpec } from '../self-implement/graph-yaml.js';
@@ -215,6 +219,17 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
   const parsed = parseGraphTemplateYaml(stringifyYaml(document), path);
   if (!parsed.template || parsed.errors.length) throw new Error(parsed.errors.map((e) => `${e.path}: ${e.message}`).join('\n'));
   const graph = parsed.template;
+  const pluginRoot = elanousStateRoot();
+  const graphFile = realpathSync(path);
+  const installed = listInstalledPlugins(pluginRoot);
+  const owner = installed.find(item => {
+    const graphsDir = join(item.path, 'graphs');
+    return existsSync(graphsDir) && graphFile.startsWith(`${realpathSync(graphsDir)}${sep}`);
+  });
+  const credentials = owner ? pluginEnv(owner.name, pluginRoot) : {};
+  const declaredEnv = [...new Set(installed.map(item => item.name))]
+    .flatMap(name => credentialStatus(name, pluginRoot).fields.map(field => field.env));
+  const credentialFields = owner ? credentialStatus(owner.name, pluginRoot).fields.filter(field => field.set).map(field => field.name) : [];
   for (const terminal of graph.terminalNodes) {
     if (terminal !== 'done' && terminal !== 'failed') {
       throw new Error(`unsupported terminal node: ${terminal} (expected done or failed)`);
@@ -390,17 +405,32 @@ export async function runGraph(path: string, options: GraphRunOptions = {}): Pro
       mkdirSync(dirname(contextPath), { recursive: true });
       writeFileSync(contextPath, JSON.stringify({ graphId, runId, nodeId: current, input: state.input ?? null, outputs }, null, 2) + '\n');
       let code: number | null = null;
+      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) => {
         const result = await (options.deps?.runBash ?? realRunBash)(body, opts);
         code = result.exitCode;
-        return result;
+        return { ...result, stdout: redactCredentials(result.stdout), stderr: redactCredentials(result.stderr) };
       };
-      const ctx = { arguments: '', artifactsDir: dirname(statePath), outputs: {}, resolvedProvider: undefined, resolvedModel: undefined, toolPolicy: {}, env: { ...process.env, ELANOUS_GRAPH_CONTEXT: contextPath, ELANOUS_GRAPH_DIR: dirname(resolve(path)) } } as NodeExecContext;
+      if (owner) debug.log('plugin.credentials', 'injected', { plugin: owner.name, fields: credentialFields, count: credentialFields.length });
+      const env = { ...process.env };
+      for (const key of declaredEnv) delete env[key];
+      Object.assign(env, credentials);
+      // 러너가 명시로 받은 우주(`--config-dir`)를 `cmd:` 자식에 못 박는다 — 자식이 코드 위치(소스 트리)로 시험 우주를 새로 고르던 구멍
+      //   (09-30 🅢 스튜어드: 작업 트리 `graph run … --config-dir ~/.elanous` 의 자식 triage 가 «apiKey missing» · 0.2.5 컷 릴리스 루프도 같은 발사 줄).
+      if (getElanousConfigDirOverride()) {
+        env.ELANOUS_CONFIG_DIR = getElanousConfigDir();
+        env.ELANOUS_STATE_DIR = effectiveInstanceRoot();
+        debug.log('graph-runner', 'child-universe-pinned', { graphId, runId, node: current, configDir: env.ELANOUS_CONFIG_DIR, stateDir: env.ELANOUS_STATE_DIR });
+      }
+      env.ELANOUS_GRAPH_CONTEXT = contextPath;
+      env.ELANOUS_GRAPH_DIR = dirname(resolve(path));
+      const ctx = { arguments: '', artifactsDir: dirname(statePath), outputs: {}, resolvedProvider: undefined, resolvedModel: undefined, toolPolicy: {}, env } as NodeExecContext;
       const result = await executeBashNode({ id: current, type: 'bash', bash: command.command, ...(command.timeout_ms ? { idle_timeout: command.timeout_ms } : {}) } as BashNode, ctx, { runBash } as WorkflowDeps);
       output = result.output;
       ok = result.ok;
       exit = code;
-      error = result.error;
+      error = result.error ? redactCredentials(result.error) : undefined;
       state.executed++;
     }
     if (resumingCompleted && completed) {

package/src/grounding/token.ts

@@ -3,7 +3,7 @@
  *  Pod 는 호스트 우주를 «직접» 읽지 않는다(4우주·최소 자격). 대신 호스트 `POST /v1/grounding/query` 에
  *  «질의 → 인용»만 묻는다. 그 문을 여는 것이 이 토큰이다.
  *  - 모양: `base64url(payload).base64url(HMAC-SHA256)` · payload = `{v:1, runId, job, scope, exp}`.
- *    scope 는 `'grounding'` 또는 `'llm-credential'` — 같은 서명·검증·회수. 문은 scope 를 엄격히 가른다.
+ *    scope 는 `'grounding'` · `'llm-credential'` · `'gh-credential'` — 같은 서명·검증·회수. 문은 scope 를 엄격히 가른다.
  *  - 상태 없는 검증 — 엔드포인트는 `verifyGroundingToken` 하나만 부른다.
  *  - 키: 비밀 백엔드 `grounding/hmac`(없으면 처음 발급 때 무작위 32바이트로 만든다) — 호스트 밖으로 안 나간다.
  *  - 수명: `exp`(Job 기한) ⊕ 조기 회수 `revokeGroundingRun(runId)`(Job 이 끝나면 호스트가 부른다).
@@ -19,13 +19,15 @@ export const GROUNDING_TOKEN_ENV = 'ELANOUS_GROUNDING_TOKEN';
 export const GROUNDING_URL_ENV = 'ELANOUS_GROUNDING_URL';
 export const GROUNDING_HMAC_SECRET_ID = 'grounding/hmac';
 
-export const GROUNDING_TOKEN_SCOPES = ['grounding', 'llm-credential'] as const;
+export const GROUNDING_TOKEN_SCOPES = ['grounding', 'llm-credential', 'gh-credential'] as const;
 export type GroundingTokenScope = (typeof GROUNDING_TOKEN_SCOPES)[number];
 
 export interface GroundingClaims {
   readonly runId: string;
   readonly job: string;
   readonly scope: GroundingTokenScope;
+  /** GitHub credential relay only: full owner/repository bound by the host at issuance. */
+  readonly repository?: string;
   readonly exp: number;
 }
 
@@ -59,19 +61,22 @@ function sign(payload: string, key: string): string {
 }
 
 export async function mintGroundingToken(
-  claims: { runId: string; job: string; ttlMs: number; scope?: GroundingTokenScope },
+  claims: { runId: string; job: string; ttlMs: number; scope?: GroundingTokenScope; repository?: string },
   deps: GroundingTokenDeps = {},
 ): Promise<{ token: string; exp: number }> {
   const key = await (deps.key ?? (() => readKey(true)))();
   if (!key) throw new Error('grounding: 서명 키를 만들 수 없다(비밀 백엔드)');
   const scope: GroundingTokenScope = claims.scope ?? 'grounding';
+  if (claims.repository !== undefined && (scope !== 'gh-credential' || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(claims.repository) || claims.repository.split('/').some((part) => part === '.' || part === '..'))) {
+    throw new Error('grounding: invalid credential repository');
+  }
   const exp = (deps.now ?? Date.now)() + claims.ttlMs;
-  const payload = Buffer.from(JSON.stringify({ v: 1, runId: claims.runId, job: claims.job, scope, exp })).toString('base64url');
+  const payload = Buffer.from(JSON.stringify({ v: 1, runId: claims.runId, job: claims.job, scope, ...(scope === 'gh-credential' ? { repository: claims.repository } : {}), exp })).toString('base64url');
   debug.log('grounding.token', 'minted', { runId: claims.runId, job: claims.job, scope, exp });
   return { token: `${payload}.${sign(payload, key)}`, exp };
 }
 
-/** 그라운딩 문은 scope `'grounding'` 만 받는다. `llm-credential` 은 `expectedScope` 로 따로 연다. */
+/** 그라운딩 문은 scope `'grounding'` 만 받는다. 자격 증명 scope 는 `expectedScope` 로 따로 연다. */
 export async function verifyGroundingToken(
   token: string,
   deps: GroundingTokenDeps & { readonly expectedScope?: GroundingTokenScope } = {},
@@ -92,9 +97,10 @@ export async function verifyGroundingToken(
   if (claims.v !== 1 || typeof claims.runId !== 'string' || typeof claims.job !== 'string' || typeof claims.exp !== 'number') return reject('malformed');
   const expected: GroundingTokenScope = deps.expectedScope ?? 'grounding';
   if (claims.scope !== expected) return reject('scope', claims.runId);
+  if (expected === 'gh-credential' && claims.repository !== undefined && (typeof claims.repository !== 'string' || !/^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(claims.repository) || claims.repository.split('/').some((part) => part === '.' || part === '..'))) return reject('malformed', claims.runId);
   if ((deps.now ?? Date.now)() >= claims.exp) return reject('expired', claims.runId);
   if (isRevoked(claims.runId, deps)) return reject('revoked', claims.runId);
-  return { ok: true, runId: claims.runId, job: claims.job, scope: expected, exp: claims.exp };
+  return { ok: true, runId: claims.runId, job: claims.job, scope: expected, ...(expected === 'gh-credential' && claims.repository !== undefined ? { repository: claims.repository } : {}), exp: claims.exp };
 }
 
 /** Job 이 끝나면 호스트가 부른다 — 그 런의 토큰은 기한 전이라도 더는 안 통한다. */

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

@@ -1,9 +1,10 @@
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { Command, Option } from 'commander';
 import { runGitCommand } from '../git-fs/runner.js';
-import { GOAL_TYPES, parseGoalType, type GoalType } from '../self-implement/goal-author.js';
+import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, tracedPathReferences, type GoalType } from '../self-implement/goal-author.js';
 import { templateForGoalType } from '../self-implement/graph-templates.js';
 import { listRunLedgers, loadFederatedRunLedger, loadRunLedger, runLedgerDir, type RunLedgerMatch } from '../self-implement/run-ledger.js';
 import { resolveChildLlmEffort, resolveImplementationChildModel } from '../self-dev/dev-cli.js';
@@ -12,6 +13,7 @@ import { queryRunningRuns } from '../self-implement/running-runs.js';
 import { DevPipelineError } from '../self-dev/dev-pipeline.js';
 import { runDraftSweep, type DraftSweepAdapters, type DraftSweepResult, type SweepDraft, type SweepMergedPr } from '../self-dev/draft-sweep.js';
 import { debug } from '../debug/log.js';
+import { dispatchTask, type DispatchTaskInput, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
 import { PR_LABELS } from '../github/pr-labels.js';
 import { decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInputs } from '../self-implement/budget-gate.js';
 import { installDeliverableVerifyCliCommand, type InstallDeliverableVerifyCliDeps } from './deliverable-verify-cli.js';
@@ -198,13 +200,16 @@ function printHarnessAskMarkerDryRun(goalPath?: string): void {
     const warnings = inspectHarnessAskMarkerWarnings(ask);
     if (warnings.length === 0) {
       console.log('[dry-run] ✅ ask 마커 — 경고 없음');
-      return;
+    } else {
+      for (const warning of warnings) console.log(`[dry-run] ⚠️ ask 마커 — ${warning}`);
     }
-    for (const warning of warnings) console.log(`[dry-run] ⚠️ ask 마커 — ${warning}`);
   } catch (error) {
     const message = error instanceof Error ? error.message.split('\n')[0] : String(error);
     console.log(`[dry-run] ⚠️ ask 마커 — 검사 실패: ${message}`);
   }
+  for (const finding of lintGoalFile(ask, 'main').filter(({ tag }) => tag === 'release-note')) {
+    console.log(`[dry-run] ⚠️ 릴리스 노트 — ${finding.message}`);
+  }
 }
 
 function printHarnessLaunchDryRun(preview: {
@@ -218,7 +223,9 @@ function printHarnessLaunchDryRun(preview: {
   console.log(`[dry-run] 입력: ${preview.input}`);
   console.log(`[dry-run] 입구: ${preview.entrance}`);
   console.log(`[dry-run] 시작 예정: ${preview.wouldStart}`);
-  console.log('[dry-run] 전제 검사: ask 마커만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음');
+  console.log(preview.goalPath
+    ? '[dry-run] 전제 검사: ask 마커·릴리스 노트 린트만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음'
+    : '[dry-run] 전제 검사: ask 마커만 돌렸다 · 원격 조회(열린 PR·런 원장)는 돌리지 않음');
   printHarnessAskMarkerDryRun(preview.goalPath);
   if (preview.goalPath) console.log(renderGoalTemplateDryRun(preview.goalPath, preview.goalType));
   if (preview.target !== undefined) {
@@ -315,7 +322,8 @@ function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubs
   return resolved;
 }
 /** ⭐ 런 계약의 실행 칸 = pod — 호스트는 그래프를 안 돌리고 Pod 로 보낸다(harness-pod-dispatch.ts). */
-async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-say', input: string, pool: string): Promise<void> {
+async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-say', input: string, pool: string,
+  recordDispatch: (input: DispatchTaskInput, deps?: DispatchTaskDeps) => ReturnType<typeof dispatchTask> = dispatchTask): Promise<void> {
   const o = opts as HarnessSubstrateOpts;
   if (o.target !== undefined) {
     debug.log('harness.pod', 'target-refused', { target: o.target });
@@ -324,10 +332,59 @@ async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-s
     process.exitCode = 2;
     return;
   }
+  let dispatchRecorded = false;
+  try {
+    const goalText = entrance === 'cli-harness-ask' ? readFileSync(input, 'utf8') : input;
+    await recordDispatch({
+      goalId: (entrance === 'cli-harness-ask' ? parseGoalId(goalText) : null)
+        ?? `request-${createHash('sha256').update(goalText).digest('hex').slice(0, 32)}`,
+      title: goalText.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+      goalText,
+      targetPaths: entrance === 'cli-harness-ask' ? tracedPathReferences(goalText).map((reference) => reference.path) : [],
+      spec: { input: entrance === 'cli-harness-ask' ? { file: input } : { text: input }, humanReadableOutput: false },
+    });
+    dispatchRecorded = true;
+  } catch (error) {
+    try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+  }
   const { dispatchHarnessOnPod } = await import('./harness-pod-dispatch.js');
-  const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}) });
+  let output = '';
+  const status = await dispatchHarnessOnPod({ entrance, input, podPool: pool, ...(dispatchRecorded ? { dispatchRecorded: true } : {}), ...(o.podMemory ? { podMemory: o.podMemory } : {}), ...(o.autoMerge === false ? { autoMerge: false } : {}), ...(o.base ? { base: o.base } : {}), ...(o.json ? { json: true } : {}), ...(o.source ? { source: o.source } : {}) },
+    entrance === 'cli-harness-ask' ? { onOutput: (text) => { output = (output + text).slice(-16_000); } } : {});
   if (status !== 0) {
-    console.error('Pod 실행에 닿지 못했다 — 풀·컨텍스트·SSH 연결을 확인하거나 `--substrate local` 로 명시하라');
+    let childError: string | undefined;
+    let podFailure: string | undefined;
+    let podJobFailed = false;
+    if (entrance === 'cli-harness-ask') {
+      for (const line of output.split('\n').reverse()) {
+        if (!line.trimStart().startsWith('[{') || !line.includes('"error"')) continue;
+        try {
+          const results: unknown = JSON.parse(line);
+          if (!Array.isArray(results)) continue;
+          for (const result of results) {
+            if (!result || typeof result !== 'object') continue;
+            const error = (result as { error?: { code?: string; message?: string } }).error;
+            if (typeof error?.code !== 'string' || typeof error.message !== 'string' || !error.code.startsWith('pod-')) continue;
+            if (error.code === 'pod-job-failed') {
+              podJobFailed = true;
+              childError = error.message.split('childError=')[1]?.split('\n', 1)[0];
+            }
+            podFailure = error.message;
+            break;
+          }
+        } catch { /* Non-result stdout cannot establish that a Pod child ran. */ }
+        if (podFailure) break;
+      }
+      if (!podFailure) {
+        const summary = output.split('\n').find((line) => /\s❌\sfailed · .* — pod-[\w-]+: /.test(line));
+        podFailure = summary?.split(/\s❌\sfailed · .* — pod-[\w-]+: /)[1];
+        podJobFailed = summary?.includes(' — pod-job-failed: ') ?? false;
+        if (podJobFailed) childError = podFailure?.split('childError=')[1]?.split('\n', 1)[0];
+      }
+    }
+    if (podJobFailed && childError && childError !== 'no-result-line') console.error(`Pod 안 자식이 실패했다 — ${childError}`);
+    else if (podFailure) console.error(`Pod 실행이 실패했다 — ${podFailure.split('\n', 1)[0]}`);
+    else console.error('Pod 실행에 닿지 못했다 — 풀·컨텍스트·SSH 연결을 확인하거나 `--substrate local` 로 명시하라');
     process.exitCode = status;
   }
 }
@@ -1502,6 +1559,8 @@ export interface HarnessCliCommandDeps {
   draftSweep?: HarnessDraftSweepDeps;
   ask?: HarnessAskHandler;
   say?: HarnessSayHandler;
+  /** Observe-only Pod host dispatch seam. */
+  podDispatchTask?: (input: DispatchTaskInput, deps?: DispatchTaskDeps) => ReturnType<typeof dispatchTask>;
   plan?: HarnessPlanHandler;
   /** ⭐ `plan` 주입이 «없을 때» 가는 기본 분기. 시험이 이 자리로 «CLI 의 기본 배선»을 문다
    *  (⛔ 주입된 `plan` 이 파일을 스스로 만들면 그 시험은 배선을 «못 답한다» — 무인 리뷰 GOODHART 지적). */
@@ -1540,7 +1599,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
               process.exitCode = 2;
               return Promise.resolve();
             }
-            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-ask', goalPath, resolved.pool!) : ask(goalPath, normalizeHarnessAskSayOptions(opts));
+            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-ask', goalPath, resolved.pool!, deps.podDispatchTask) : ask(goalPath, normalizeHarnessAskSayOptions(opts));
           },
         );
       });
@@ -1564,7 +1623,7 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
               process.exitCode = 2;
               return Promise.resolve();
             }
-            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-say', sentence.join(' '), resolved.pool!) : say(sentence, normalizeHarnessAskSayOptions(opts));
+            return resolved.substrate === 'pod' ? onPod(opts, 'cli-harness-say', sentence.join(' '), resolved.pool!, deps.podDispatchTask) : say(sentence, normalizeHarnessAskSayOptions(opts));
           },
         );
       });

package/src/harness/harness-pod-dispatch.ts

@@ -19,6 +19,8 @@ export interface HarnessPodDispatchInput {
   /** say 의 문장, 또는 ask 의 골 문서 경로. */
   readonly input: string;
   readonly podPool?: string;
+  /** Host already recorded the observe-only dispatch; suppress a second decision in the Pod. */
+  readonly dispatchRecorded?: boolean;
   /** Pod 메모리 등급(standard|high) — 오케스트레이터 환경 `ELANOUS_POD_MEMORY_TIER` 로 Job 까지 간다. */
   readonly podMemory?: string;
   readonly autoMerge?: boolean;
@@ -49,7 +51,7 @@ export function podOrchestrateArgs(input: HarnessPodDispatchInput, goal: string)
   ];
 }
 
-type PodDispatchDeps = { run?: (cmd: string, args: readonly string[], env: NodeJS.ProcessEnv) => number | null; readFile?: (path: string) => string; cwd?: string; spawnChild?: typeof spawn };
+type PodDispatchDeps = { run?: (cmd: string, args: readonly string[], env: NodeJS.ProcessEnv) => number | null; readFile?: (path: string) => string; cwd?: string; spawnChild?: typeof spawn; onOutput?: (text: string) => void };
 
 export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDispatchDeps & { run: NonNullable<PodDispatchDeps['run']> }): number;
 export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps?: PodDispatchDeps): number | Promise<number>;
@@ -68,6 +70,8 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
   const args = podOrchestrateArgs(input, goal);
   const env = { ...process.env };
   delete env.ELANOUS_POD_GOAL_DOC;
+  delete env.ELANOUS_DISPATCH_RECORDED;
+  if (input.dispatchRecorded) env.ELANOUS_DISPATCH_RECORDED = '1';
   if (input.podMemory) env.ELANOUS_POD_MEMORY_TIER = input.podMemory;
   if (input.entrance === 'cli-harness-ask') {
     const root = findGitDir(cwd)?.root;
@@ -84,7 +88,9 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
     goalChars: goal.length, ...(input.entrance === 'cli-harness-ask' ? { goalPath: input.input } : {}),
   });
   const run = deps.run ?? ((cmd: string, a: readonly string[], childEnv: NodeJS.ProcessEnv) => new Promise<number>((resolveStatus) => {
-    const child = (deps.spawnChild ?? spawn)(cmd, [...a], { stdio: 'inherit', env: childEnv });
+    const child = (deps.spawnChild ?? spawn)(cmd, [...a], { stdio: deps.onOutput ? ['inherit', 'pipe', 'inherit'] : 'inherit', env: childEnv });
+    child.stdout?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk: string) => { process.stdout.write(chunk); deps.onOutput?.(chunk); });
     let forwarded: NodeJS.Signals | undefined;
     const forward = (signal: NodeJS.Signals) => {
       forwarded = signal;