elanous 0.2.5 → 0.2.7

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

@@ -0,0 +1,220 @@
+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';
+import { debug } from '../../debug/log.js';
+import { runGraph } from '../../graph-runner/runner.js';
+import { parseGraphTemplateYaml } from '../../self-implement/graph-yaml.js';
+import { installPlugin } from '../install/plugin-install.js';
+
+const CAPABILITIES = ['fs:workdir', 'proc:bun', 'proc:elanous'];
+const isRecord = (value: unknown): value is Record<string, unknown> => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+export interface MakePluginDeps {
+  codex: (dir: string, prompt: string) => Promise<void>;
+  install?: typeof installPlugin;
+  runGraph?: typeof runGraph;
+}
+export interface MakePluginOptions {
+  request: string;
+  name?: string;
+  parentDir?: string;
+  run?: boolean;
+  input?: unknown;
+  deps?: MakePluginDeps;
+}
+export interface MakePluginResult {
+  status: 'installed' | 'ran' | 'failed';
+  dir: string;
+  plugin: string;
+  graph: string;
+  errors: string[];
+  runStatus?: Awaited<ReturnType<typeof runGraph>>['status'];
+  timings: { scaffold: number; write: number; validate: number; repair?: number; install: number; run?: number };
+}
+
+/** 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 {
+  mkdirSync(join(dir, 'graphs'));
+  mkdirSync(join(dir, 'examples'));
+  writeFileSync(join(dir, 'plugin.json'), JSON.stringify({ name: slug, version: '0.1.0', description: request,
+    extensions: { 'ai.elanous': { graphs: [`./graphs/${slug}.yaml`], capabilities: CAPABILITIES } } }, null, 2) + '\n');
+  writeFileSync(join(dir, 'graphs', `${slug}.yaml`), `graph_id: ${slug}\nversion: 1\nentry_node: main\nterminal_nodes: [done, failed]\nnodes:\n  - { node_id: main, kind: agent, recipe: 'cmd:main', max_visits: 1 }\n  - { node_id: done, kind: gate, recipe: none, max_visits: 1 }\n  - { node_id: failed, kind: gate, recipe: none, max_visits: 1 }\nedges:\n  - { from: main, on: outcome, map: { ok: done, fail: failed } }\n`);
+  writeFileSync(join(dir, 'graphs', 'recipes.yaml'), `main:\n  command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" main'\n  timeout_ms: 120000\n`);
+  writeFileSync(join(dir, 'graphs', 'run-step.ts'), `import { readFileSync } from 'node:fs';\nconst context = JSON.parse(readFileSync(process.env.ELANOUS_GRAPH_CONTEXT!, 'utf8'));\nconsole.log(JSON.stringify({ outcome: 'ok', input: context.input }));\n`);
+  writeFileSync(join(dir, 'examples', 'input.json'), '{}\n');
+  writeFileSync(join(dir, 'README.md'), `# ${slug}\n\n${request}\n\nRun the installed graph with examples/input.json as input. No messages are sent.\n`);
+}
+
+function inside(dir: string, path: string): string | undefined {
+  const full = resolve(dir, path);
+  return full.startsWith(`${dir}${sep}`) ? full : undefined;
+}
+
+function realTarget(path: string): string {
+  let ancestor = path;
+  while (!existsSync(ancestor)) {
+    const next = dirname(ancestor);
+    if (next === ancestor) throw new Error(`cannot resolve plugin directory: ${path}`);
+    ancestor = next;
+  }
+  return resolve(realpathSync(ancestor), relative(ancestor, path));
+}
+
+function assertLocalParent(parent: string): void {
+  const repoPlugins = realpathSync(resolve(import.meta.dir, '../../../plugins'));
+  const target = realTarget(parent);
+  if (target === repoPlugins || target.startsWith(`${repoPlugins}${sep}`)) {
+    throw new Error('repository plugins/ is not a local plugin directory');
+  }
+}
+
+export async function validatePluginDir(dir: string): Promise<string[]> {
+  const errors: string[] = [];
+  let manifest: unknown;
+  try {
+    const file = join(dir, 'plugin.json');
+    if (lstatSync(file).isSymbolicLink()) errors.push('안전하지 않은 plugin.json 링크');
+    else manifest = JSON.parse(readFileSync(file, 'utf8'));
+  }
+  catch (error) { errors.push(`plugin.json 파싱 실패: ${String(error)}`); }
+  const extension = isRecord(manifest) && isRecord(manifest.extensions) ? manifest.extensions['ai.elanous'] : undefined;
+  const graphs = isRecord(extension) ? extension.graphs : undefined;
+  if (isRecord(extension) && extension.contributes !== undefined) errors.push('extension contributes 덮어쓰기 금지');
+  if (!isRecord(manifest) || typeof manifest.name !== 'string' || !/^[a-z0-9][a-z0-9-]{1,39}$/.test(manifest.name) || typeof manifest.version !== 'string') errors.push('plugin.json 이름/버전 오류');
+  if (isRecord(manifest) && (manifest.capabilities !== undefined || manifest.contributes !== undefined || manifest.main !== undefined)) errors.push('plugin.json 최상위 권한/기여/main 덮어쓰기 금지');
+  if (!isRecord(extension) || !Array.isArray(extension.capabilities) || JSON.stringify(extension.capabilities) !== JSON.stringify(CAPABILITIES)) {
+    errors.push('capabilities 는 ["fs:workdir","proc:bun","proc:elanous"] 이어야 한다');
+  }
+  if (!Array.isArray(graphs) || graphs.length === 0 || !graphs.every(g => typeof g === 'string')) errors.push('plugin.json graphs 경로 없음');
+  let recipes: unknown;
+  try {
+    const file = join(dir, 'graphs', 'recipes.yaml');
+    if (lstatSync(file).isSymbolicLink()) errors.push('안전하지 않은 recipes.yaml 링크');
+    else recipes = parseYaml(readFileSync(file, 'utf8'));
+  }
+  catch (error) { errors.push(`recipes.yaml 파싱 실패: ${String(error)}`); }
+  if (!isRecord(recipes)) errors.push('recipes.yaml 은 맵이어야 한다');
+  else for (const [id, recipe] of Object.entries(recipes)) {
+    if (!isRecord(recipe) || typeof recipe.command !== 'string' || !recipe.command.trim() ||
+      (recipe.timeout_ms !== undefined && (!Number.isSafeInteger(recipe.timeout_ms) || Number(recipe.timeout_ms) <= 0))) errors.push(`잘못된 recipe: ${id}`);
+  }
+  for (const graph of Array.isArray(graphs) ? graphs : []) {
+    if (typeof graph !== 'string') continue;
+    const file = inside(dir, graph);
+    if (!file || !/^\.\/graphs\/[a-zA-Z0-9_-]+\.ya?ml$/.test(graph)) { errors.push(`안전하지 않은 graph 경로: ${graph}`); continue; }
+    try {
+      if (lstatSync(file).isSymbolicLink()) { errors.push(`안전하지 않은 graph 링크: ${graph}`); continue; }
+      const parsed = parseGraphTemplateYaml(readFileSync(file, 'utf8'), file);
+      errors.push(...parsed.errors.map(issue => `${issue.path}: ${issue.message}`));
+      const template = parsed.template;
+      if (!template) continue;
+      if (!/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(template.graphId)) errors.push(`잘못된 graph_id: ${template.graphId}`);
+      if (template.terminalNodes.length !== 2 || !template.terminalNodes.includes('done') || !template.terminalNodes.includes('failed')) errors.push('terminal_nodes 는 done, failed 이어야 한다');
+      const executionNodes = template.nodes.filter(node => !template.terminalNodes.includes(node.nodeId));
+      if (executionNodes.length < 2 || executionNodes.length > 6) errors.push(`실행 노드는 2~6개여야 한다: ${executionNodes.length}개`);
+      for (const node of template.nodes) {
+        if (node.recipe.startsWith('cmd:')) {
+          const id = node.recipe.slice(4);
+          if (!isRecord(recipes) || !isRecord(recipes[id]) || typeof recipes[id].command !== 'string' || !recipes[id].command) errors.push(`recipe ${id} 없음`);
+        } else if (node.recipe !== 'none') errors.push(`지원하지 않는 recipe: ${node.recipe}`);
+      }
+    } catch (error) { errors.push(`${graph} 파싱 실패: ${String(error)}`); }
+  }
+  const visit = (path: string): void => {
+    for (const entry of readdirSync(path, { withFileTypes: true })) {
+      const file = join(path, entry.name);
+      if (entry.isSymbolicLink() || (!entry.isDirectory() && !entry.isFile())) { errors.push(`안전하지 않은 파일: ${file}`); continue; }
+      if (entry.isDirectory()) visit(file);
+      else if (/\.[cm]?[jt]sx?$/.test(entry.name)) {
+        const source = readFileSync(file, 'utf8');
+        for (const match of source.matchAll(/\b(?:import|export)\s*(?:[\s\S]*?\s+from\s*)?["']([^"']+)["']|\b(?:import|require)\s*\(\s*["']([^"']+)["']/g)) {
+          const target = match[1] ?? match[2]!;
+          if (/(?:^|\/)src\//.test(target) && (target.startsWith('/') || target.startsWith('.'))) errors.push(`src import 금지: ${file}: ${target}`);
+        }
+      }
+    }
+  };
+  try { visit(dir); } catch (error) { errors.push(`파일 검사 실패: ${String(error)}`); }
+  try {
+    const example = join(dir, 'examples', 'input.json');
+    if (lstatSync(example).isSymbolicLink()) errors.push('안전하지 않은 examples/input.json 링크');
+    else JSON.parse(readFileSync(example, 'utf8'));
+  } catch (error) { errors.push(`examples/input.json 파싱 실패: ${String(error)}`); }
+  const step = join(dir, 'graphs', 'run-step.ts');
+  try {
+    if (!existsSync(step)) errors.push('run-step.ts 없음');
+    else if (errors.some(error => error.startsWith('안전하지 않은 파일:'))) return errors;
+    else {
+      const build = await Bun.build({ entrypoints: [step], target: 'bun' });
+      if (!build.success) errors.push(...build.logs.map(log => `run-step.ts 문법 오류: ${log.message}`));
+    }
+  } catch (error) { errors.push(`run-step.ts 문법 오류: ${String(error)}`); }
+  return errors;
+}
+
+export async function makePlugin({ request, name, parentDir, run, input, deps }: MakePluginOptions): Promise<MakePluginResult> {
+  const slug = (name ?? request).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '').slice(0, 32).replace(/-$/, '') || `plugin-${Date.now()}`;
+  if (!request.trim() || !/^[a-z0-9][a-z0-9-]{1,39}$/.test(slug)) throw new Error(`invalid plugin request or name: ${slug}`);
+  if (name !== undefined && !/^[a-z0-9][a-z0-9-]{1,31}$/.test(name)) throw new Error(`invalid --name slug: ${name}`);
+  const root = elanousStateRoot();
+  const parent = resolve(parentDir ?? join(root, 'plugins-local'));
+  assertLocalParent(parent);
+  const dir = join(parent, slug);
+  if (existsSync(dir)) throw new Error(`plugin directory already exists: ${dir}`);
+  const timings: MakePluginResult['timings'] = { scaffold: 0, write: 0, validate: 0, install: 0 };
+  const result: MakePluginResult = { status: 'failed', dir, plugin: slug, graph: join(dir, 'graphs', `${slug}.yaml`), errors: [], timings };
+  const step = async (stage: keyof MakePluginResult['timings'], action: () => void | Promise<void>): Promise<void> => {
+    const start = performance.now();
+    try { await action(); }
+    finally { const ms = Math.round(performance.now() - start); timings[stage] = ms; debug.log('plugin.maker', stage, { ms, errors: result.errors }); }
+  };
+  try {
+    await step('scaffold', () => { mkdirSync(parent, { recursive: true }); mkdirSync(dir); scaffold(dir, slug, request); });
+    const codex = deps?.codex ?? codexWrite;
+    const prompt = `요청 원문:\n${request}\n\n이 폴더의 뼈대를 수정해 작동하는 로컬 그래프 플러그인을 작성하라. plugin.json extensions["ai.elanous"].graphs 와 capabilities 는 유지하고, graphs/<id>.yaml 은 entry_node, terminal_nodes: [done, failed], nodes 의 recipe: 'cmd:<id>', edges 의 on: outcome, map: { ok, fail } 을 써라. graphs/recipes.yaml 에 모든 cmd:<id> 의 command: 'bun "$ELANOUS_GRAPH_DIR/run-step.ts" <id>' 와 timeout_ms 를 선언하라. graphs/run-step.ts 의 각 단계 stdout 마지막 줄은 JSON {outcome, ...} 이며 이전 출력은 ELANOUS_GRAPH_CONTEXT JSON 의 outputs 에 있다. src/ import 금지. 엘라누스 기능은 CLI elanous ask --json 또는 elanous research --json 로만 사용. 아무것도 보내지 말 것. 실행 노드는 2~6개. examples/input.json 에 실제로 돌릴 입력을 넣을 것. 폴더 밖에는 쓰지 말 것.`;
+    await step('write', () => codex(dir, prompt));
+    await step('validate', async () => { result.errors = await validatePluginDir(dir); });
+    if (result.errors.length) {
+      await step('repair', () => codex(dir, `${prompt}\n\n아래 오류를 모두 수리하라:\n${result.errors.join('\n')}`));
+      await step('validate', async () => { result.errors = await validatePluginDir(dir); });
+    }
+    if (result.errors.length) return result;
+    let installedPath = '';
+    await step('install', async () => { installedPath = (await (deps?.install ?? installPlugin)(dir, { yes: true, root })).path; });
+    result.status = 'installed';
+    const graph = JSON.parse(readFileSync(join(dir, 'plugin.json'), 'utf8')).extensions['ai.elanous'].graphs[0] as string;
+    result.graph = resolve(installedPath, graph);
+    if (run) {
+      await step('run', async () => {
+        const value = input === undefined ? JSON.parse(readFileSync(join(dir, 'examples', 'input.json'), 'utf8')) : input;
+        result.runStatus = (await (deps?.runGraph ?? runGraph)(result.graph, { input: value })).status;
+      });
+      result.status = result.runStatus === 'done' ? 'ran' : 'failed';
+      if (result.status === 'failed') result.errors.push(`graph run: ${result.runStatus}`);
+    }
+  } catch (error) {
+    result.status = 'failed';
+    result.errors.push(error instanceof Error ? error.message : String(error));
+  }
+  return result;
+}

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