elanous 0.2.6 → 0.2.8

package/src/plugins/maker/node-maker.ts

@@ -0,0 +1,139 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join, resolve, sep } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { debug } from '../../debug/log.js';
+import { getNodeKindRegistration, listNodeKinds, unregisterPluginNodeKind } from '../../graph-kinds/registry.js';
+import { loadPluginNodes } from '../../graph-kinds/plugin-nodes.js';
+import { loadPluginManifestFromDir } from '../core/manifest.js';
+import { codexWrite } from './plugin-maker.js';
+
+export interface AddNodeOptions {
+  dir: string;
+  request: string;
+  kind?: string;
+  deps?: { codex: (dir: string, prompt: string) => Promise<void> };
+}
+
+export interface AddNodeResult {
+  status: 'added' | 'failed';
+  dir: string;
+  kind: string;
+  node: string;
+  errors: string[];
+  timings: { write: number; validate: number; repair?: number };
+  version?: string;
+}
+
+const KIND = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const VERSION = /^(\d+)\.(\d+)\.(\d+)$/;
+
+function nodeErrors(dir: string, path: string, kind: string, manifest: ReturnType<typeof loadPluginManifestFromDir>['manifest']): string[] {
+  const errors: string[] = [];
+  let node: unknown;
+  try {
+    if (lstatSync(path).isSymbolicLink() || !realpathSync(path).startsWith(`${realpathSync(dir)}${sep}`)) {
+      return ['unsafe node path'];
+    }
+    node = parseYaml(readFileSync(path, 'utf8'));
+  } catch (error) { return [`node YAML read/parse failed: ${String(error)}`]; }
+  if (!node || typeof node !== 'object' || Array.isArray(node)) return ['node must be an object'];
+  const spec = node as Record<string, unknown>;
+  if (spec.kind !== kind) errors.push(`node kind must be ${kind}`);
+  if (spec.graph !== 'workflow') errors.push('node graph must be workflow');
+  if (errors.length) return errors;
+  // The loader is the same validation path used by plugin installation. Register under a
+  // temporary identity so installed kinds cannot collide with this inspection.
+  const inspectionId = `inspect-${randomUUID().replaceAll('-', '')}`;
+  try {
+    errors.push(...loadPluginNodes(dir, { ...manifest, id: inspectionId,
+      contributes: { ...manifest.contributes, nodes: [`./nodes/${kind}.yaml`] } }).errors);
+  } finally {
+    for (const entry of listNodeKinds()) {
+      if (entry.plugin !== inspectionId) continue;
+      const registered = getNodeKindRegistration(entry.graph, entry.kind);
+      if (registered) unregisterPluginNodeKind(entry.graph, entry.kind, inspectionId, registered);
+    }
+  }
+  return errors;
+}
+
+export async function addNode({ dir: inputDir, request, kind: requestedKind, deps }: AddNodeOptions): Promise<AddNodeResult> {
+  const dir = resolve(inputDir);
+  const kind = requestedKind ?? request.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  if (!request.trim() || !KIND.test(kind)) throw new Error(`invalid node request or kind: ${kind}`);
+  const manifestFile = join(dir, 'plugin.json');
+  if (!existsSync(manifestFile) || lstatSync(manifestFile).isSymbolicLink()) throw new Error(`plugin.json missing or unsafe: ${manifestFile}`);
+  const { manifest } = loadPluginManifestFromDir(dir, { id: 'local-plugin' });
+  const original = readFileSync(manifestFile);
+  const raw: unknown = JSON.parse(original.toString('utf8'));
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw) || typeof (raw as Record<string, unknown>).version !== 'string'
+    || !VERSION.test((raw as Record<string, unknown>).version as string)) throw new Error('plugin.json requires a numeric major.minor.patch version');
+  const nodesDir = join(dir, 'nodes');
+  const nodesEntry = lstatSync(nodesDir, { throwIfNoEntry: false });
+  if (nodesEntry && !nodesEntry.isDirectory()) throw new Error(`unsafe nodes directory: ${nodesDir}`);
+  const path = join(nodesDir, `${kind}.yaml`);
+  if (lstatSync(path, { throwIfNoEntry: false }) || manifest.contributes.nodes?.some(node => node === `./nodes/${kind}.yaml`)) throw new Error(`node already exists: ${kind}`);
+  const root = realpathSync(dir);
+  for (const declared of manifest.contributes.nodes ?? []) {
+    const declaredPath = resolve(dir, declared);
+    const entry = lstatSync(declaredPath, { throwIfNoEntry: false });
+    if (!entry) continue;
+    if (!entry.isFile() || !realpathSync(declaredPath).startsWith(`${root}${sep}`)) {
+      throw new Error(`unsafe declared node path: ${declared}`);
+    }
+    const spec: unknown = parseYaml(readFileSync(declaredPath, 'utf8'));
+    if (spec && typeof spec === 'object' && !Array.isArray(spec)
+      && (spec as Record<string, unknown>).kind === kind) throw new Error(`node already exists: ${kind}`);
+  }
+  const timings: AddNodeResult['timings'] = { write: 0, validate: 0 };
+  const result: AddNodeResult = { status: 'failed', dir, kind, node: path, errors: [], timings };
+  const step = async (stage: keyof typeof timings, action: () => void | Promise<void>): Promise<void> => {
+    const start = performance.now();
+    try { await action(); }
+    finally { timings[stage] = Math.round(performance.now() - start); debug.log('plugin.node-maker', stage, { ms: timings[stage], errors: result.errors }); }
+  };
+  const prompt = `요청 원문:\n${request}\n\n이 플러그인에 workflow 노드 종류 ${kind} 하나만 작성하라. nodes/${kind}.yaml 파일만 작성하고 plugin.json 및 다른 파일은 변경하지 말 것. graph: workflow, kind: ${kind}, inputs: { type: object }, run: 의 bash/http/skill/mcp 중 정확히 하나를 정의하라. harness 노드 및 코드 실행기/다른 플러그인 파일은 만들지 말 것. 폴더 밖에는 쓰지 말 것.`;
+  try {
+    mkdirSync(nodesDir, { recursive: true });
+    await step('write', () => (deps?.codex ?? codexWrite)(dir, prompt));
+    const validate = () => {
+      const entry = lstatSync(manifestFile, { throwIfNoEntry: false });
+      if (!entry) { result.errors = ['plugin.json was deleted — restore it unchanged']; return; }
+      result.errors = !entry.isSymbolicLink() && readFileSync(manifestFile).equals(original)
+        ? nodeErrors(dir, path, kind, manifest) : ['plugin.json was modified'];
+    };
+    await step('validate', validate);
+    if (result.errors.length) {
+      await step('repair', () => (deps?.codex ?? codexWrite)(dir, `${prompt}\n\n아래 오류를 모두 수리하라:\n${result.errors.join('\n')}`));
+      await step('validate', validate);
+    }
+    if (result.errors.length) return result;
+    const data = raw as Record<string, unknown>;
+    const [, major, minor, patch] = (data.version as string).match(VERSION)!;
+    data.version = `${major}.${minor}.${BigInt(patch!) + 1n}`;
+    const extension = (data.extensions as Record<string, unknown> | undefined)?.['ai.elanous'];
+    if (extension && typeof extension === 'object' && !Array.isArray(extension)) {
+      const entry = extension as Record<string, unknown>;
+      entry.nodes = [...(manifest.contributes.nodes ?? []), `./nodes/${kind}.yaml`];
+    } else {
+      const contributes = (data.contributes ??= {}) as Record<string, unknown>;
+      contributes.nodes = [...(manifest.contributes.nodes ?? []), `./nodes/${kind}.yaml`];
+    }
+    writeFileSync(manifestFile, JSON.stringify(data, null, 2) + '\n');
+    result.version = data.version as string;
+    result.status = 'added';
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  } finally {
+    if (result.status === 'failed') {
+      try {
+        if (lstatSync(manifestFile, { throwIfNoEntry: false })?.isSymbolicLink()) unlinkSync(manifestFile);
+        if (!existsSync(manifestFile) || !readFileSync(manifestFile).equals(original)) writeFileSync(manifestFile, original);
+      } catch (error) {
+        result.errors.push(`plugin.json restoration failed: ${String(error)}`);
+      }
+    }
+  }
+  return result;
+}

package/src/plugins/maker/plugin-maker.ts

@@ -1,4 +1,5 @@
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, readdirSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { dirname, join, relative, resolve, sep } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
@@ -33,12 +34,23 @@ export interface MakePluginResult {
   timings: { scaffold: number; write: number; validate: number; repair?: number; install: number; run?: number };
 }
 
-export async function codexWrite(dir: string, prompt: string): Promise<void> {
-  const child = Bun.spawn(['codex', 'exec', '-C', dir, '-s', 'workspace-write', '--skip-git-repo-check', '-o', join(dir, '.codex-last-message.txt'), prompt], {
-    cwd: dir, stdin: 'ignore', stdout: 'ignore', stderr: 'pipe',
-  });
-  const [code, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
-  if (code !== 0) throw new Error(`codex exec failed (${code}): ${stderr.trim().slice(0, 500)}`);
+/** Run codex in the plugin folder without leaving run debris there: the last message goes to a temp file, and a
+ *  `.elanous/` that the run created (debug logs and a `latest` symlink from elanous processes codex starts in that
+ *  folder) is removed — the installer refuses symlinks, so the debris made every freshly written plugin uninstallable
+ *  (10-01 live `plugin node add`). A `.elanous/` that existed before the run is left alone. */
+export async function codexWrite(dir: string, prompt: string, bin = 'codex'): Promise<void> {
+  const scratch = mkdtempSync(join(tmpdir(), 'elanous-codex-'));
+  const stateDirExisted = existsSync(join(dir, '.elanous'));
+  try {
+    const child = Bun.spawn([bin, 'exec', '-C', dir, '-s', 'workspace-write', '--skip-git-repo-check', '-o', join(scratch, 'last-message.txt'), prompt], {
+      cwd: dir, stdin: 'ignore', stdout: 'ignore', stderr: 'pipe',
+    });
+    const [code, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+    if (code !== 0) throw new Error(`codex exec failed (${code}): ${stderr.trim().slice(0, 500)}`);
+  } finally {
+    if (!stateDirExisted) rmSync(join(dir, '.elanous'), { recursive: true, force: true });
+    rmSync(scratch, { recursive: true, force: true });
+  }
 }
 
 function scaffold(dir: string, slug: string, request: string): void {

package/src/policy/llm-policy.ts

@@ -0,0 +1,268 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { isScalar, parseDocument } from 'yaml';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { DEFAULT_FALLBACK_CHAIN, isFallbackStep, type FallbackStep } from '../oauth/fallback-chain.js';
+import { isCodexQuotaPolicy } from '../oauth/codex-quota-policy.js';
+import { DEFAULT_BUDGET_GATE_MAX_USED_PERCENT, MODEL_ROLES, RUNTIME_LLM_PROVIDER_NAMES, parseRoleLlmEntry, type RoleLlmConfig } from '../user-config.js';
+
+export interface LlmPolicy {
+  version: 1;
+  default: { provider: string; model?: string };
+  roles: RoleLlmConfig;
+  fallback: FallbackStep[];
+  accounts: { codex: {
+    order: string[];
+    rotateAtPercent: number;
+    perAccount: Record<string, { rotateAtPercent: number; until?: string; why?: string }>;
+    rotationEnabled: boolean;
+  } };
+  credits: {
+    codex: 'use' | 'fallback' | 'never';
+    grants: Array<{ account: string; amount: number; expires: string; source: string }>;
+    pace?: { targetPerDay: number; until: string; why?: string };
+  };
+  caps: { codex: { harness: number; pod: number; tox: number; intake: number; headroom: number }; grok: { weekly: number; tox: number; intake: number } };
+  resetCredits: { redeem: 'human' };
+  alerts: { lowRemainingPercent: number; resetCreditExpiryDays: number; creditsStep: number };
+}
+
+export type LlmPolicySource = 'default' | 'legacy-config' | 'file';
+export interface LlmPolicyValidation {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+export interface LoadedLlmPolicy extends LlmPolicyValidation {
+  policy: LlmPolicy;
+  sources: Record<string, LlmPolicySource>;
+  path: string;
+  filePresent: boolean;
+}
+export interface LoadLlmPolicyOptions {
+  /** All file IO remains scoped to this directory; tests can pass a temporary directory. */
+  configDir?: string;
+  path?: string;
+  /** An already-read legacy config; when omitted the sibling config.json is read directly. */
+  legacyConfig?: unknown;
+  now?: Date;
+}
+
+type Obj = Record<string, unknown>;
+const object = (v: unknown): v is Obj => v !== null && typeof v === 'object' && !Array.isArray(v);
+const percent = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v) && v >= 0 && v <= 100;
+const nonempty = (v: unknown): v is string => typeof v === 'string' && v.trim().length > 0;
+const positive = (v: unknown): v is number => typeof v === 'number' && Number.isFinite(v) && v > 0;
+const date = (v: unknown): v is string => typeof v === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(v) && !Number.isNaN(Date.parse(`${v}T00:00:00Z`)) && new Date(`${v}T00:00:00Z`).toISOString().slice(0, 10) === v;
+
+function setOwn(target: Obj, key: string, value: unknown): void {
+  Object.defineProperty(target, key, { value, configurable: true, enumerable: true, writable: true });
+}
+
+/** Today's code defaults, not a snapshot of one machine's user config. */
+export function defaultLlmPolicy(): LlmPolicy {
+  return {
+    version: 1,
+    default: { provider: 'auto' },
+    roles: {},
+    fallback: [...DEFAULT_FALLBACK_CHAIN],
+    accounts: { codex: { order: [], rotateAtPercent: 95, perAccount: { default: { rotateAtPercent: 60 } }, rotationEnabled: true } },
+    credits: { codex: 'fallback', grants: [] },
+    caps: {
+      codex: { harness: DEFAULT_BUDGET_GATE_MAX_USED_PERCENT['openai-codex']!, pod: 95, tox: 60, intake: 80, headroom: 15 },
+      grok: { weekly: DEFAULT_BUDGET_GATE_MAX_USED_PERCENT.grok!, tox: 50, intake: 48 },
+    },
+    resetCredits: { redeem: 'human' },
+    alerts: { lowRemainingPercent: 10, resetCreditExpiryDays: 7, creditsStep: 5000 },
+  };
+}
+
+function leafPaths(value: unknown, prefix = ''): string[] {
+  if (!object(value) || Object.keys(value).length === 0) return prefix ? [prefix] : [];
+  return Object.entries(value).flatMap(([key, item]) => leafPaths(item, prefix ? `${prefix}.${key}` : key));
+}
+
+/** Validate the partial policy document. Unknown fields and invalid values are errors, not silent overrides. */
+export function validateLlmPolicy(input: unknown): LlmPolicyValidation {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  if (!object(input)) return { valid: false, errors: ['policy must be a mapping'], warnings };
+  const check = (node: unknown, path: string, schema: Obj): void => {
+    if (!object(node)) { errors.push(`${path} must be a mapping`); return; }
+    for (const [key, value] of Object.entries(node)) {
+      if (!Object.hasOwn(schema, key)) { errors.push(`unknown field ${path}.${key}`); continue; }
+      const rule = schema[key];
+      if (object(rule)) check(value, `${path}.${key}`, rule);
+      else if (typeof rule === 'function' && !(rule as (v: unknown) => boolean)(value)) errors.push(`${path}.${key} is invalid`);
+    }
+  };
+  const dateField = (v: unknown) => date(v);
+  const perAccount = (v: unknown) => object(v) && Object.entries(v).every(([key, row]) => nonempty(key) && object(row)
+    && Object.keys(row).every(k => ['rotateAtPercent', 'until', 'why'].includes(k))
+    && percent(row.rotateAtPercent) && (row.until === undefined || date(row.until)) && (row.why === undefined || nonempty(row.why)));
+  const grants = (v: unknown) => Array.isArray(v) && v.every(g => object(g)
+    && Object.keys(g).every(k => ['account', 'amount', 'expires', 'source'].includes(k))
+    && nonempty(g.account) && positive(g.amount) && date(g.expires) && nonempty(g.source));
+  const roles = (v: unknown) => object(v) && Object.entries(v).every(([role, spec]) => MODEL_ROLES.some(r => r === role)
+    && object(spec) && Object.keys(spec).every(k => ['provider', 'tier', 'model'].includes(k)) && parseRoleLlmEntry(spec).ok);
+  check(input, 'policy', {
+    version: (v: unknown) => v === 1,
+    default: { provider: (v: unknown) => nonempty(v) && RUNTIME_LLM_PROVIDER_NAMES.some(p => p === v), model: nonempty },
+    roles,
+    fallback: (v: unknown) => Array.isArray(v) && v.length > 0 && v.every(isFallbackStep) && new Set(v).size === v.length,
+    accounts: { codex: {
+      order: (v: unknown) => Array.isArray(v) && v.every(nonempty) && new Set(v).size === v.length,
+      rotateAtPercent: percent, perAccount, rotationEnabled: (v: unknown) => typeof v === 'boolean',
+    } },
+    credits: {
+      codex: (v: unknown) => v === 'use' || v === 'fallback' || v === 'never',
+      grants,
+      pace: (v: unknown) => object(v) && positive(v.targetPerDay) && dateField(v.until)
+        && (v.why === undefined || nonempty(v.why))
+        && Object.keys(v).every(k => ['targetPerDay', 'until', 'why'].includes(k)),
+    },
+    caps: { codex: { harness: percent, pod: percent, tox: percent, intake: percent, headroom: percent },
+      grok: { weekly: percent, tox: percent, intake: percent } },
+    resetCredits: { redeem: (v: unknown) => v === 'human' },
+    alerts: { lowRemainingPercent: percent, resetCreditExpiryDays: positive, creditsStep: positive },
+  });
+  if (input.version !== undefined && input.version !== 1) warnings.push('unsupported policy version');
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+function merge(base: Obj, overlay: Obj, sources: Record<string, LlmPolicySource>, source: LlmPolicySource, prefix = ''): void {
+  for (const [key, value] of Object.entries(overlay)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (object(value) && Object.hasOwn(base, key) && object(base[key])) merge(base[key] as Obj, value, sources, source, path);
+    else {
+      setOwn(base, key, value !== null && typeof value === 'object' ? structuredClone(value) : value);
+      for (const leaf of leafPaths(value, path)) setOwn(sources, leaf, source);
+    }
+  }
+}
+
+/** The date is inclusive: a rule with until=2026-10-29 remains active through that UTC day. */
+function removeExpired(input: Obj, now: Date, warnings: string[], prefix = ''): void {
+  for (const [key, value] of Object.entries(input)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (path === 'credits.grants' && Array.isArray(value)) {
+      input[key] = value.filter(grant => {
+        if ((grant as { expires: string }).expires >= now.toISOString().slice(0, 10)) return true;
+        warnings.push(`${path} ${String((grant as { account: string }).account)} expired on ${String((grant as { expires: string }).expires)}; ignored`);
+        return false;
+      });
+      continue;
+    }
+    if (!object(value)) continue;
+    if (typeof value.until === 'string' && date(value.until) && value.until < now.toISOString().slice(0, 10)) {
+      delete input[key];
+      warnings.push(`${path} expired on ${value.until}; ignored`);
+    } else removeExpired(value, now, warnings, path);
+  }
+}
+
+export function loadLlmPolicy(opts: LoadLlmPolicyOptions = {}): LoadedLlmPolicy {
+  const configDir = opts.configDir ?? getElanousConfigDir();
+  const path = opts.path ?? join(configDir, 'policy', 'llm.yaml');
+  const policy = defaultLlmPolicy();
+  const sources: Record<string, LlmPolicySource> = Object.fromEntries(leafPaths(policy).map(p => [p, 'default']));
+  const warnings: string[] = [];
+  const errors: string[] = [];
+  let legacy: unknown = opts.legacyConfig;
+  if (legacy === undefined) {
+    const legacyPath = join(configDir, 'config.json');
+    try { legacy = JSON.parse(readFileSync(legacyPath, 'utf8')); }
+    catch (error) {
+      if (!(error instanceof Error && 'code' in error && error.code === 'ENOENT')) {
+        warnings.push(`legacy config ${legacyPath} could not be loaded: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      legacy = {};
+    }
+  }
+  if (object(legacy)) {
+    const llm = object(legacy.llm) ? legacy.llm : {};
+    const overlay: Obj = {};
+    const add = (key: string, value: unknown, target: Obj, targetKey: string, valid: (v: unknown) => boolean): void => {
+      if (value === undefined) return;
+      if (valid(value)) { setOwn(target, targetKey, value); warnings.push(`legacy config ${key} applies; migrate to policy/llm.yaml`); }
+      else warnings.push(`legacy config ${key} is invalid; ignored`);
+    };
+    const base: Obj = {};
+    add('llm.provider', llm.provider, base, 'provider', v => nonempty(v) && RUNTIME_LLM_PROVIDER_NAMES.some(p => p === v));
+    add('llm.model', llm.model, base, 'model', nonempty);
+    if (Object.keys(base).length) overlay.default = base;
+    add('roleLlm', legacy.roleLlm, overlay, 'roles', v => object(v) && Object.entries(v).every(([r, spec]) => MODEL_ROLES.some(k => k === r) && parseRoleLlmEntry(spec).ok));
+    add('llm.fallbackChain', llm.fallbackChain, overlay, 'fallback', v => Array.isArray(v) && v.length > 0 && v.every(isFallbackStep) && new Set(v).size === v.length);
+    const codex: Obj = {};
+    add('llm.codexAccountOrder', llm.codexAccountOrder, codex, 'order', v => Array.isArray(v) && v.every(nonempty));
+    add('llm.codexAccountRotation', llm.codexAccountRotation, codex, 'rotationEnabled', v => typeof v === 'boolean');
+    add('llm.codexAccountRotationThresholdPercent', llm.codexAccountRotationThresholdPercent, codex, 'rotateAtPercent', percent);
+    if (object(llm.codexAccountRotationThresholdPercentByAccount)) {
+      const rows: Obj = {};
+      for (const [account, value] of Object.entries(llm.codexAccountRotationThresholdPercentByAccount)) {
+        add(`llm.codexAccountRotationThresholdPercentByAccount.${account}`, value, rows, account, percent);
+        if (Object.hasOwn(rows, account)) setOwn(rows, account, { rotateAtPercent: rows[account] });
+      }
+      if (Object.keys(rows).length) codex.perAccount = rows;
+    }
+    if (Object.keys(codex).length) overlay.accounts = { codex };
+    const credits: Obj = {};
+    if (llm.codexQuotaPolicy !== undefined) {
+      if (isCodexQuotaPolicy(llm.codexQuotaPolicy)) {
+        credits.codex = { credits: 'use', fallback: 'fallback', 'within-quota': 'never' }[llm.codexQuotaPolicy];
+        warnings.push('legacy config llm.codexQuotaPolicy applies; migrate to policy/llm.yaml');
+      } else warnings.push('legacy config llm.codexQuotaPolicy is invalid; ignored');
+    }
+    if (credits.codex === undefined && llm.codexCreditsAllowed === true) {
+      credits.codex = 'use';
+      warnings.push('legacy config llm.codexCreditsAllowed applies; migrate to policy/llm.yaml');
+    }
+    if (Object.keys(credits).length) overlay.credits = credits;
+    const gate = object(legacy.harness) && object(legacy.harness.budgetGate) ? legacy.harness.budgetGate : {};
+    const caps: Obj = {};
+    const harness: Obj = {};
+    add('harness.budgetGate.minHeadroomPercent', gate.minHeadroomPercent, harness, 'headroom', percent);
+    if (object(gate.maxUsedPercent)) {
+      add('harness.budgetGate.maxUsedPercent.openai-codex', gate.maxUsedPercent['openai-codex'], harness, 'harness', percent);
+      const grok: Obj = {};
+      add('harness.budgetGate.maxUsedPercent.grok', gate.maxUsedPercent.grok, grok, 'weekly', percent);
+      if (Object.keys(grok).length) caps.grok = grok;
+    }
+    if (Object.keys(harness).length) caps.codex = harness;
+    if (Object.keys(caps).length) overlay.caps = caps;
+    merge(policy as unknown as Obj, overlay, sources, 'legacy-config');
+  }
+  // Read directly: `existsSync` is also false when the folder cannot be searched (EACCES), which would
+  // report an unreadable policy as «no file · valid». Only ENOENT/ENOTDIR mean the file is absent.
+  let raw: string | undefined;
+  let filePresent = false;
+  try {
+    raw = readFileSync(path, 'utf8');
+    filePresent = true;
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+      filePresent = true;
+      errors.push(`cannot read policy file ${path}: ${code ?? (error instanceof Error ? error.message : String(error))}`);
+    }
+  }
+  if (raw !== undefined) {
+    try {
+      const doc = parseDocument(raw, { uniqueKeys: true });
+      if (doc.errors.length) throw new Error(doc.errors.map(e => e.message).join('; '));
+      const emptyDocument = doc.contents === null || (isScalar(doc.contents) && doc.contents.type === 'PLAIN' && doc.contents.source === '');
+      const parsed: unknown = emptyDocument ? {} : doc.toJS();
+      const validation = validateLlmPolicy(parsed);
+      errors.push(...validation.errors);
+      warnings.push(...validation.warnings);
+      if (validation.valid && object(parsed)) {
+        const filtered = structuredClone(parsed);
+        removeExpired(filtered, opts.now ?? new Date(), warnings);
+        merge(policy as unknown as Obj, filtered, sources, 'file');
+      }
+    } catch (error) {
+      errors.push(`invalid policy file ${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { policy, sources, path, filePresent, valid: errors.length === 0, errors, warnings };
+}

package/src/prompt-library/session-guidance.ts

@@ -115,9 +115,15 @@ export function buildSessionGuidanceAddendum(
   }
 
   if (items.length === 0) return [];
+  // B4 — 파일 수 규칙. 명령을 실제로 돌릴 도구(Bash·PtyShellStart·WebTerminal*)가 있을 때만 `git ls-files` 로 세라고 하고,
+  // Read 만 켜진 세션에선 셀 수 없으니 추측하지 말고 확인 불가라고 답하게 한다(EVAL q09 «959» vs 실측 778 · 리뷰 3라운드 must-fix).
+  const canRunCommands = enabledTools.some(name => /^(Bash|PtyShellStart|WebTerminal)/.test(name));
+  const fileCountRule = canRunCommands
+    ? '저장소의 파일 수·목록은 저장소 루트에서 `git ls-files <경로>`로 추적 파일 기준으로 센다 — 하위 디렉터리에서 실행 중이면 저장소 루트로 이동해서 세고, 다른 기준이면 그 기준을 답에 적는다.'
+    : '이 세션에는 명령을 실행할 도구가 없다 — 저장소의 파일 수는 추측하지 말고 «이 모드에서는 셀 수 없다»고 답한다(도구로 센 목록이 대화에 있으면 그 기준을 밝히고 쓴다).';
   return [{
     role: 'system',
-    content: '# Session-specific guidance\n\n' +
+    content: `${fileCountRule}\n\n` + '# Session-specific guidance\n\n' +
       items.map(s => `- ${s}`).join('\n'),
   }];
 }

package/src/prompt-library/universal-preamble.ts

@@ -60,8 +60,8 @@ export const PROJECT_TREE_MAX_CHARS = 8 * 1024;
 export const PROJECT_TREE_DIR_ENTRY_LIMIT = 20;
 
 const NO_TOOLS_VERIFICATION_GUIDANCE = `## Chat without tools — verify rather than guess
-This conversation has tools disabled. Do not guess repository or real-time facts that require verification, such as file counts, file contents, commits, or the current time. Say you cannot check them here. The project tree above is for navigation, not evidence for counts.
-To check these facts, enable tools with \`elanous agent …\` or \`elanous chat --tools …\`.`;
+This conversation has tools disabled. Do not guess repository or real-time facts that require verification, such as file counts, file contents, commits, or the current date or time. When asked for facts you cannot verify here (including repository state, files, and dates), explicitly say you cannot check them in this mode. The project tree above is for navigation, not evidence for counts.
+Give one line explaining how to enable tools: \`elanous agent "<your question>"\`.`;
 
 // P4 (2026-05-03) — Family-agnostic coding-agent lifecycle. Maps the
 // three user-facing pipelines to an explicit tool-batch sequence so every

package/src/relay/relay-cli.ts

@@ -0,0 +1,20 @@
+import type { Command } from 'commander';
+
+/** `elanous relay serve` — 릴레이 서버(R2 · 내부 문서 `RFC-mobile-relay-without-tailscale-2026-09-30` A5).
+ *  index.ts 원문을 잘라 보는 시험(첫 `.command('serve')` = mcp)을 흔들지 않게 등록을 여기 둔다. */
+export function registerRelayCommand(program: Command): void {
+  const relayCmd = program.command('relay').description('Encrypted WebSocket relay');
+  relayCmd.command('serve')
+    .description('Serve paired relay connections using operator-provisioned host signing keys')
+    .requiredOption('--trusted-host-keys <file>', 'JSON object of X25519-derived serverId to Ed25519 public key (base64url)')
+    .option('--port <port>', 'Listening port', '8765')
+    .action(async (opts: { trustedHostKeys: string; port: string }) => {
+      const port = Number(opts.port);
+      if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error('invalid relay port');
+      const { loadTrustedHostKeys, startRelayServer } = await import('./relay-server.js');
+      const relay = startRelayServer({ port, trustedHostKeys: loadTrustedHostKeys(opts.trustedHostKeys) });
+      console.log(`relay listening on 127.0.0.1:${relay.port}`);
+      process.once('SIGINT', () => { relay.stop(); });
+      process.once('SIGTERM', () => { relay.stop(); });
+    });
+}