elanous 0.2.13 → 0.2.14

package/graphs/release/release-loop.yaml

@@ -30,6 +30,7 @@ nodes:
   - { node_id: npm-publish, kind: git, recipe: 'cmd:npm-publish', max_visits: 1 }
   - { node_id: docs-land, kind: git, recipe: 'cmd:docs-land', max_visits: 1 }
   - { node_id: verify, kind: gate, recipe: 'cmd:verify', max_visits: 1 }
+  - { node_id: vault-note, kind: gate, recipe: 'cmd:vault-note', max_visits: 1 }
   - { node_id: ops-upgrade, kind: agent, recipe: 'cmd:ops-upgrade', max_visits: 1 }
   - { node_id: version-dev-bump, kind: git, recipe: 'cmd:version-dev-bump', max_visits: 1 }
   - { node_id: done, kind: gate, max_visits: 1 }
@@ -54,6 +55,8 @@ edges:
   - { from: publish, on: outcome, map: { ok: npm-publish, fail: failed, error: failed } }
   - { from: npm-publish, on: outcome, map: { ok: docs-land, fail: docs-land, error: docs-land } }
   - { from: docs-land, on: outcome, map: { ok: verify, fail: failed, error: failed } }
-  - { from: verify, on: outcome, map: { ok: ops-upgrade, fail: failed, error: failed } }
+  - { from: verify, on: outcome, map: { ok: vault-note, fail: failed, error: failed } }
+  # Warning-only: vault note failures after publication never block operational upgrades.
+  - { from: vault-note, on: outcome, map: { ok: ops-upgrade, fail: ops-upgrade, error: ops-upgrade } }
   - { from: ops-upgrade, on: outcome, map: { ok: version-dev-bump, fail: version-dev-bump, error: version-dev-bump } }
   - { from: version-dev-bump, on: outcome, map: { ok: done, fail: failed, error: failed } }

package/graphs/rhythm/daily.yaml

@@ -0,0 +1,38 @@
+graph_id: rhythm-daily
+loop:
+  title: 데일리 리뷰
+  description: 어제 착지·판·루프·그리드·결정·위험·외부 동향을 한 장으로 읽는다
+  trigger:
+    cron: '30 8 * * *'
+version: 1
+entry_node: collect
+terminal_nodes: [done, failed]
+nodes:
+  - node_id: collect
+    kind: agent
+    recipe: cmd:collect
+    max_visits: 1
+  - node_id: compose
+    kind: agent
+    recipe: cmd:compose
+    max_visits: 1
+  - node_id: deliver
+    kind: agent
+    recipe: cmd:deliver
+    max_visits: 1
+  - node_id: done
+    kind: gate
+    max_visits: 1
+  - node_id: failed
+    kind: gate
+    max_visits: 1
+edges:
+  - from: collect
+    on: outcome
+    map: { ok: compose, fail: compose }
+  - from: compose
+    on: outcome
+    map: { ok: deliver, fail: failed }
+  - from: deliver
+    on: outcome
+    map: { ok: done, fail: failed }

package/graphs/rhythm/recipes.yaml

@@ -0,0 +1,18 @@
+collect:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../scripts/rhythm/daily.ts" collect --json'
+  timeout_ms: 400000
+compose:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../scripts/rhythm/daily.ts" compose --json'
+  timeout_ms: 30000
+deliver:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../scripts/rhythm/daily.ts" deliver --json'
+  timeout_ms: 30000
+weekly-collect:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../scripts/rhythm/weekly.ts" collect --json'
+  timeout_ms: 400000
+weekly-compose:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../scripts/rhythm/weekly.ts" compose --json'
+  timeout_ms: 30000
+weekly-deliver:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../scripts/rhythm/weekly.ts" deliver --json'
+  timeout_ms: 30000

package/graphs/rhythm/weekly.yaml

@@ -0,0 +1,39 @@
+graph_id: rhythm-weekly
+loop:
+  title: 주간 미팅 자료
+  description: 지난주 성과·이번 주 판·현안·이행 대조·결정·외부 동향을 한 장으로 읽는다
+  trigger:
+    cron: '0 9 * * 1'
+version: 1
+entry_node: collect
+terminal_nodes: [done, failed]
+nodes:
+  - node_id: collect
+    kind: agent
+    recipe: cmd:weekly-collect
+    max_visits: 1
+  - node_id: compose
+    kind: agent
+    recipe: cmd:weekly-compose
+    max_visits: 1
+  - node_id: deliver
+    kind: agent
+    recipe: cmd:weekly-deliver
+    max_visits: 1
+  - node_id: done
+    kind: gate
+    max_visits: 1
+  - node_id: failed
+    kind: gate
+    max_visits: 1
+edges:
+  # A failed collect must not let compose deliver an older file of the same week (review round 3).
+  - from: collect
+    on: outcome
+    map: { ok: compose, fail: failed }
+  - from: compose
+    on: outcome
+    map: { ok: deliver, fail: failed }
+  - from: deliver
+    on: outcome
+    map: { ok: done, fail: failed }

package/graphs/video/recipes.yaml

@@ -0,0 +1,3 @@
+summary:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../scripts/video/youtube-summary.ts"'
+  timeout_ms: 120000

package/graphs/video/youtube-summary.yaml

@@ -0,0 +1,17 @@
+graph_id: youtube-summary
+version: 1
+loop:
+  title: Built-in YouTube summary
+  description: Turn video captions (or STT) into a local summary or study note; no publishing or external skill.
+  exec_request: true
+  inputs: [url, format]
+  trigger:
+    events: [manual]
+entry_node: summary
+terminal_nodes: [done, failed]
+nodes:
+  - { node_id: summary, kind: agent, recipe: 'cmd:summary', max_visits: 1 }
+  - { node_id: done, kind: gate, max_visits: 1 }
+  - { node_id: failed, kind: gate, max_visits: 1 }
+edges:
+  - { from: summary, on: outcome, map: { ok: done, no-transcript: done, invalid-video-id: failed, fail: failed } }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elanous",
   "mcpName": "io.github.ElanvitalAI/elanous",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "Self-healing coding harness where eyes, hands, and memory all turn on one sentence — it authors its own goals, implements them in isolated worktrees, and reviews its own work.",
   "license": "Apache-2.0",
   "author": "Elanvital AI",

package/scripts/audit-test-state-writes.ts

@@ -34,18 +34,13 @@ const statePattern = /(?:\b(?:homedir|HOME|ELANOUS_(?:STATE|CONFIG|NEXUS)_DIR|EL
 export type StaticIsolationSignal = 'ELANOUS_STATE_DIR' | '--config-dir' | 'mkdtemp';
 export type StaticSafetyClassification = 'isolated' | 'manual-review';
 
-const inspectedManualReviews: Record<string, string> = {
-  'src/autopilot/build/config-isolation.test.ts': 'setElanousConfigDir redirects the tested config into an isolated worktree path; SHA assertions prove the real config is unchanged.',
-  'test/artifact-store.test.ts': 'the apparent writes target an in-memory ArtifactFs fake, not the host filesystem.',
-  'test/pty-drive-workdir-decision.test.ts': 'setElanousConfigDir receives only /tmp paths and the afterEach reset restores the override.',
-  'test/working-dir.test.ts': 'the fixed test root is derived from tmpdir() and removed by afterAll.',
-};
-
 export type WriterCall = {
   line: number;
   pattern: string;
   staticIsolationSignals: StaticIsolationSignal[];
   staticSafety: StaticSafetyClassification;
+  /** The expanded target names the real home (homedir(), $HOME, ~/) — the only writer calls that fail the audit. */
+  realHomeTarget: boolean;
 };
 
 type AuditFinding = {
@@ -123,8 +118,10 @@ export function classifyStaticIsolation(text: string): { signals: StaticIsolatio
   return { signals, safety: signals.length ? 'isolated' : 'manual-review' };
 }
 
-function writerIsolation(source: ts.SourceFile, writer: ts.CallExpression | ts.NewExpression, name: string): { signals: StaticIsolationSignal[]; safety: StaticSafetyClassification } {
-  if (name === 'mkdtemp' || name === 'mkdtempSync') return { signals: ['mkdtemp'], safety: 'isolated' };
+const REAL_HOME_TARGET = /\bhomedir\s*\(|process\.env\.HOME\b|process\.env\[\s*['"]HOME['"]\s*\]|['"`]~\//;
+
+function writerIsolation(source: ts.SourceFile, writer: ts.CallExpression | ts.NewExpression, name: string): { signals: StaticIsolationSignal[]; safety: StaticSafetyClassification; realHomeTarget: boolean } {
+  if (name === 'mkdtemp' || name === 'mkdtempSync') return { signals: ['mkdtemp'], safety: 'isolated', realHomeTarget: false };
   const variables = new Map<string, string>();
   const visit = (node: ts.Node): void => {
     if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) variables.set(node.name.text, node.initializer.getText(source));
@@ -138,7 +135,40 @@ function writerIsolation(source: ts.SourceFile, writer: ts.CallExpression | ts.N
     return `(${expand(variables.get(name)!)})`;
   });
   const argumentsText = writer.arguments?.map((argument) => argument.getText(source)).join(' ') ?? '';
-  return classifyStaticIsolation(expand(argumentsText));
+  return { ...classifyStaticIsolation(expand(argumentsText)), realHomeTarget: realHomeTarget(source, writer) };
+}
+
+/** Lexically nearest declaration of `name` visible before `at` (same file-wide name reused across tests must not leak). */
+function scopedInitializer(source: ts.SourceFile, at: ts.Node, name: string): ts.Expression | undefined {
+  for (let scope: ts.Node | undefined = at.parent; scope; scope = scope.parent) {
+    if (!ts.isBlock(scope) && !ts.isSourceFile(scope) && !ts.isModuleBlock(scope)) continue;
+    let found: ts.Expression | undefined;
+    for (const statement of scope.statements) {
+      if (statement.pos >= at.pos) break;
+      if (!ts.isVariableStatement(statement)) continue;
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name) && declaration.name.text === name && declaration.initializer) found = declaration.initializer;
+      }
+    }
+    if (found) return found;
+  }
+  return undefined;
+}
+
+/** Only the target path (first argument) counts — written content may mention homedir() as fixture text. */
+function realHomeTarget(source: ts.SourceFile, writer: ts.CallExpression | ts.NewExpression): boolean {
+  const target = writer.arguments?.[0];
+  if (!target) return false;
+  const seen = new Set<string>();
+  const expand = (node: ts.Node, text: string): string => text.replace(/\b[A-Za-z_$][\w$]*\b/g, (name) => {
+    if (seen.has(name)) return name;
+    const initializer = scopedInitializer(source, node, name);
+    if (!initializer) return name;
+    seen.add(name);
+    return `(${expand(initializer, initializer.getText(source))})`;
+  });
+  const expanded = expand(target, target.getText(source));
+  return REAL_HOME_TARGET.test(expanded) && classifyStaticIsolation(expanded).safety !== 'isolated';
 }
 
 export type CandidateClassification = {
@@ -158,18 +188,30 @@ export function addedCandidates(report: ReturnType<typeof auditTestStateWrites>,
   return new Set(report.findings.map(({ file }) => file).filter((file) => !previousInventory.has(file)));
 }
 
+/**
+ * Fails only writer calls whose target reaches the real home without isolation evidence. A static scan cannot
+ * follow a temp directory through function returns or parameters, so "no evidence" alone stays visible as
+ * manual review in the rendered inventory instead of failing hundreds of mkdtemp-backed writes.
+ */
+export function unclassifiedCandidates(report: ReturnType<typeof auditTestStateWrites>, previousInventory: ReadonlySet<string>): string[] {
+  const { isolated, manualReview } = classifyCandidates(report, addedCandidates(report, previousInventory));
+  // The file-wide isolation label can be borrowed from a same-named temp variable in another test, so the
+  // scoped real-HOME judgement decides on every call, including ones labelled isolated.
+  return [...isolated, ...manualReview].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line)
+    .filter(({ realHomeTarget }) => realHomeTarget)
+    .map(({ file, line, pattern }) => `${file}:${line} ${pattern} — writes a real HOME path without isolation evidence`);
+}
+
 function classificationSummary(classification: CandidateClassification): string {
   const { findings, isolated, manualReview } = classification;
-  const isolatedFiles = findings.filter(({ staticSafety }) => staticSafety === 'isolated');
   const manualReviewFiles = findings.filter(({ staticSafety }) => staticSafety === 'manual-review');
   return [
     `- August 8 candidate window: **${findings.length} files** (current inventory minus the preserved August 8 inventory).`,
-    `- Candidate classification (files): **${isolatedFiles.length} ㉠ isolated** / **${manualReviewFiles.length} ㉡ manual review**.`,
-    `- ㉡ candidate files: ${manualReviewFiles.length ? manualReviewFiles.map(({ file }) => `\`${file}\``).join(', ') : '0건'}.`,
+    `- Candidate classification (files): **${findings.length - manualReviewFiles.length} ㉠ isolated** / **${manualReviewFiles.length} ㉡ manual review**.`,
     `- Writer-call evidence in the August 8 window: **${isolated.length} isolated** / **${manualReview.length} manual review**; a file is ㉡ whenever any writer call lacks a direct approved signal.`,
     `- ㉡ writer calls: ${manualReview.length ? manualReview.map(({ file, line, pattern }) => `\`${file}:${line} ${pattern}\``).join(', ') : '0건'}.`,
-    `- Manual inspection opened: **${manualReviewFiles.length}**; genuine HOME/state writers: **0건**.`,
-    ...manualReviewFiles.map(({ file }) => `- Manual inspection — \`${file}\`: ${inspectedManualReviews[file] ?? 'opened; no genuine HOME/state write established.'}`),
+    `- Manual review required: **${manualReviewFiles.length}** candidate files. This static audit does not establish whether an unclassified write targets a real HOME/state path.`,
+    ...manualReviewFiles.map(({ file }) => `- Manual review pending — \`${file}\`: isolation is unverified.`),
   ].join('\n');
 }
 
@@ -198,7 +240,7 @@ export function auditTestStateWrites(root = repo): { total: number; findings: Au
     visit(source);
     const writerCalls = writerNodes.map(({ name, node }) => {
       const classification = writerIsolation(source, node, name);
-      return { line: lineOf(source, node), pattern: formatWriterPattern(name, node, source), staticIsolationSignals: classification.signals, staticSafety: classification.safety };
+      return { line: lineOf(source, node), pattern: formatWriterPattern(name, node, source), staticIsolationSignals: classification.signals, staticSafety: classification.safety, realHomeTarget: classification.realHomeTarget };
     });
     const stateLines = text.split('\n').flatMap((line, index) => statePattern.test(line) ? [index + 1] : []);
     if (writerCalls.length && stateLines.length) {
@@ -221,8 +263,9 @@ export function auditTestStateWrites(root = repo): { total: number; findings: Au
   return { total: files.length, findings };
 }
 
-export function renderAudit(report: ReturnType<typeof auditTestStateWrites>, previous = august8Inventory(repo)): string {
+export function renderAudit(report: ReturnType<typeof auditTestStateWrites>, previous = august8Inventory(repo), reviewed = new Set(readFileSync(baselinePath, 'utf8').split('\n').filter((line) => line && !line.startsWith('#')))): string {
   const candidateWindow = classifyCandidates(report, addedCandidates(report, previous));
+  const automatic = classifyCandidates(report, addedCandidates(report, reviewed));
   const rows = report.findings.map((finding) =>
     `| \`${finding.file}\` | ${finding.writerLines.join(', ')} | ${finding.writerTargets.map((target) => `\`${target}\``).join('<br>')} | ${finding.stateLines.join(', ')} | ${finding.risk} | ${finding.isolation} | ${finding.staticSafety} (${finding.staticIsolationSignals.join(', ') || 'none'}) |`,
   );
@@ -230,6 +273,7 @@ export function renderAudit(report: ReturnType<typeof auditTestStateWrites>, pre
     '# Test Home and State Write Audit',
     '',
     'This inventory is generated by `scripts/audit-test-state-writes.ts` using TypeScript AST call detection for filesystem/state writer calls and text detection for home/state-root evidence. It covers every `*.test.*` and `*.spec.*` file under `test/` and `src/`.',
+    `Rows for files outside the reviewed baseline are a snapshot from generation time; refresh with \`${INVENTORY_REFRESH_COMMAND}\`.`,
     '',
     `- Scanned test files: **${report.total}**`,
     `- Potential home/state writers: **${report.findings.length}**`,
@@ -238,6 +282,17 @@ export function renderAudit(report: ReturnType<typeof auditTestStateWrites>, pre
     '- Static safety classification is approval-gating: only `ELANOUS_STATE_DIR`, `--config-dir`, or `mkdtemp` counts as isolated; all other candidates require manual inspection.',
     classificationSummary(candidateWindow),
     '',
+    '## 분류기 통과(자동) — 사람 검토 기준선 밖',
+    '',
+    `Reviewed baseline: \`test/test-home-state-write-audit-baseline.txt\`. Regenerate with \`${INVENTORY_REFRESH_COMMAND}\`. Only candidates with every writer call statically isolated appear below; manual-review calls fail the audits rather than expanding the baseline.`,
+    '',
+    '| File | Writer lines | Approved isolation signals |',
+    '| --- | --- | --- |',
+    ...automatic.findings.filter(({ staticSafety }) => staticSafety === 'isolated').map(({ file, writerLines, staticIsolationSignals }) =>
+      `| \`${file}\` | ${writerLines.join(', ')} | ${staticIsolationSignals.join(', ')} |`),
+    '',
+    '## 전체 스캔 (사람 검토 + 자동 분류)',
+    '',
     '| File | Writer call lines (AST) | Write target or store argument | Home/state evidence lines (text) | Risk | Current isolation evidence | Static safety |',
     '| --- | --- | --- | --- | --- | --- | --- |',
     ...rows,

package/scripts/brand/check.ts

@@ -0,0 +1,186 @@
+#!/usr/bin/env bun
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { extname, join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { debug } from '../../src/debug/log.js';
+
+type Scope = 'public-docs' | 'release-notes' | 'site' | 'deck' | 'skill' | 'any';
+type Kind = 'forbid' | 'require-form' | 'korean-in-english' | 'number-needs-source';
+type Rule = { id: string; kind: Kind; pattern: string; flags?: string; scope: Scope[]; why: string; source: string; allowInCode?: boolean; allowPattern?: string; sourcePattern?: string };
+type Finding = { file: string; line: number; id: string; match: string };
+type GlossaryEntry = { internal: string; public: string; publicForbidden: boolean };
+const scopes: Scope[] = ['public-docs', 'release-notes', 'site', 'deck', 'skill', 'any'];
+const kinds: Kind[] = ['forbid', 'require-form', 'korean-in-english', 'number-needs-source'];
+const defaultRules = join(import.meta.dir, '../../docs/brand/brand-rules.yaml');
+
+function loadRules(path: string): Rule[] {
+  const document = parseYaml(readFileSync(path, 'utf8')) as unknown;
+  if (!document || typeof document !== 'object' || !('rules' in document) || !Array.isArray(document.rules)) throw new Error(`invalid brand rules: ${path}`);
+  const glossary = 'glossary' in document ? document.glossary : [];
+  if (!Array.isArray(glossary) || !glossary.every((entry: unknown) => entry && typeof entry === 'object'
+    && typeof (entry as GlossaryEntry).internal === 'string' && typeof (entry as GlossaryEntry).public === 'string'
+    && typeof (entry as GlossaryEntry).publicForbidden === 'boolean')) throw new Error(`invalid brand glossary: ${path}`);
+  const ids = new Set<string>();
+  const rules: Rule[] = document.rules.map((candidate: unknown) => {
+    if (!candidate || typeof candidate !== 'object') throw new Error(`invalid brand rule: ${path}`);
+    const rule = candidate as Partial<Rule>;
+    if (typeof rule.id !== 'string' || !rule.id || ids.has(rule.id) || !kinds.includes(rule.kind as Kind)
+      || typeof rule.pattern !== 'string' || !rule.pattern || typeof rule.why !== 'string' || !rule.why
+      || typeof rule.source !== 'string' || !rule.source || !Array.isArray(rule.scope) || !rule.scope.length
+      || !rule.scope.every((scope) => scopes.includes(scope)) || (rule.flags !== undefined && typeof rule.flags !== 'string')
+      || (rule.allowInCode !== undefined && typeof rule.allowInCode !== 'boolean')
+      || (rule.allowPattern !== undefined && typeof rule.allowPattern !== 'string')
+      || (rule.kind === 'number-needs-source' && (typeof rule.sourcePattern !== 'string' || !rule.sourcePattern))) throw new Error(`invalid brand rule: ${path}`);
+    new RegExp(rule.pattern, rule.flags);
+    if (rule.sourcePattern) new RegExp(rule.sourcePattern, rule.flags);
+    if (rule.allowPattern) new RegExp(rule.allowPattern, rule.flags);
+    ids.add(rule.id);
+    return rule as Rule;
+  });
+  for (const entry of glossary as GlossaryEntry[]) {
+    if (!entry.publicForbidden) continue;
+    const id = `GLOSSARY-${entry.internal}`;
+    if (!entry.internal || ids.has(id)) throw new Error(`invalid brand glossary: ${path}`);
+    ids.add(id);
+    const literal = entry.internal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const pattern = `(?<![가-힣])${literal}(?![가-힣])`;
+    rules.push({ id, kind: 'forbid', pattern, scope: ['any'], why: `Use ${entry.public} instead of the internal term.`, source: `${path}#glossary` });
+  }
+  return rules;
+}
+
+function filesAt(paths: string[]): string[] {
+  const files = new Set<string>();
+  const visit = (path: string): void => {
+    const stat = statSync(path);
+    if (stat.isDirectory()) {
+      for (const entry of readdirSync(path, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        if (entry.isDirectory() || entry.isFile()) visit(join(path, entry.name));
+      }
+    } else if (stat.isFile()) files.add(path);
+  };
+  for (const path of paths) visit(resolve(path));
+  return [...files].sort();
+}
+
+function maskUiStrings(line: string): string {
+  const ui = /^\s*(?:>\s*`?\s*)?(?:(?:const|let|var)\s+)?(?:label|title|button|placeholder|ariaLabel|aria-label|tooltip|caption|uiText|uiMessage)\s*[:=]\s*(["'`])([^"'`\n]*[가-힣][^"'`\n]*)\1/;
+  const chars = line.split('');
+  const match = ui.exec(line);
+  if (match) {
+    const value = match[2]!;
+    const start = match.index + match[0].indexOf(value);
+    for (let i = start; i < start + value.length; i++) chars[i] = ' ';
+  }
+  return chars.join('');
+}
+
+function htmlVisible(content: string): string {
+  const blank = (text: string) => text.replace(/[^\r\n]/g, ' ');
+  return content.replace(/<!--[\s\S]*?-->|<(?:script|style)\b[^>]*>[\s\S]*?<\/\s*(?:script|style)\s*>/gi, blank)
+    .replace(/<(?:[^>"']|"[^"]*"|'[^']*')*>/g, (tag) => {
+      if (!/^<img\b/i.test(tag)) return blank(tag);
+      const alt = /\balt\s*=\s*(["'])(.*?)\1/is.exec(tag);
+      if (!alt) return blank(tag);
+      const offset = alt.index + alt[0].indexOf(alt[2]!);
+      return blank(tag.slice(0, offset)) + alt[2] + blank(tag.slice(offset + alt[2].length));
+    });
+}
+
+function isEnglishDocument(content: string, file: string, scope: Scope): boolean {
+  const html = ['.html', '.htm'].includes(extname(file).toLowerCase());
+  const frontmatter = /^---\s*\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content)?.[1];
+  const language = html
+    ? /<html\b[^>]*\blang\s*=\s*["']?([a-z]{2,}(?:-[a-z]+)*)/i.exec(content)?.[1]
+      ?? /<meta\b[^>]*\b(?:http-equiv\s*=\s*["']?content-language|name\s*=\s*["']?language)[^>]*\bcontent\s*=\s*["']?([a-z]{2,})/i.exec(content)?.[1]
+    : frontmatter ? /^lang(?:uage)?\s*:\s*["']?([a-z]{2,}(?:-[a-z]+)*)/im.exec(frontmatter)?.[1] : undefined;
+  if (language) return /^en(?:-|$)/i.test(language);
+  // Language-suffixed filenames are an explicit declaration, even without frontmatter.
+  if (/(?:^|[._-])(?:en|ko)(?:-[a-z]+)?\.[^.]+$/i.test(file)) return /(?:^|[._-])en(?:-[a-z]+)?\.[^.]+$/i.test(file);
+  if (scope !== 'site') return false;
+  const body = (html ? htmlVisible(content) : content.replace(/^---\s*\r?\n[\s\S]*?\r?\n---/, ''))
+    .replace(/\bElanous\b/gi, '');
+  return /\b[A-Za-z]{2,}(?:\s+[A-Za-z]{2,}){2,}\b/.test(body);
+}
+
+function findInFile(file: string, rules: Rule[], scope: Scope): Finding[] {
+  const findings: Finding[] = [];
+  const content = readFileSync(file, 'utf8');
+  const html = ['.html', '.htm'].includes(extname(file).toLowerCase());
+  const englishDocument = isEnglishDocument(content, file, scope);
+  const markdown = ['.md', '.mdx'].includes(extname(file).toLowerCase());
+  const bodyLines = html ? htmlVisible(content).split(/\r?\n/) : [];
+  let fence: { marker: string; length: number } | undefined;
+  const allLines = content.split(/\r?\n/);
+  for (const [index, line] of allLines.entries()) {
+    const lineFindings: Finding[] = [];
+    const marker = markdown ? /^ {0,3}(`{3,}|~{3,})/.exec(line)?.[1] : undefined;
+    if (marker) {
+      if (!fence) fence = { marker: marker[0]!, length: marker.length };
+      else if (marker[0] === fence.marker && marker.length >= fence.length) fence = undefined;
+    }
+    const quoted = markdown && /^\s*>/.test(line);
+    const inCode = Boolean(fence || marker || quoted);
+    for (const rule of rules) {
+      if (rule.kind === 'korean-in-english' && !englishDocument) continue;
+      const text = rule.kind === 'korean-in-english' && html ? bodyLines[index]! : line;
+      const visible = rule.allowInCode && inCode ? maskUiStrings(text) : text;
+      const allowed = rule.allowPattern ? [...line.matchAll(new RegExp(rule.allowPattern, [...new Set(`${rule.flags ?? ''}g`)].join('')))] : [];
+      const matches = visible.matchAll(new RegExp(rule.pattern, [...new Set(`${rule.flags ?? ''}g`)].join('')));
+      // B4: a measured number must carry its source marker on the same line or a neighbouring one.
+      const sourced = rule.kind === 'number-needs-source'
+        && [index - 1, index, index + 1].some((i) => i >= 0 && i < allLines.length && new RegExp(rule.sourcePattern!, rule.flags).test(allLines[i]!));
+      for (const match of matches) {
+        if (sourced) break;
+        if (allowed.some((exception) => exception.index! <= match.index! && match.index! < exception.index! + exception[0].length)) continue;
+        lineFindings.push({ file, line: index + 1, id: rule.id, match: match[0] });
+        if (rule.kind === 'korean-in-english') break;
+      }
+    }
+    findings.push(...lineFindings.filter((finding) => finding.id !== 'B11'
+      || !lineFindings.some((other) => other.id === 'BRAND-AUTONOMY' && other.match.includes(finding.match))));
+  }
+  return findings;
+}
+
+export function checkBrand(scope: Scope, paths: string[], rulesPath = defaultRules): { files: number; findings: Finding[]; rules: number; missing: boolean } {
+  if (!existsSync(rulesPath)) {
+    debug.log('brand.check', 'run', { scope, files: 0, findings: 0, rules: 0 });
+    return { files: 0, findings: [], rules: 0, missing: true };
+  }
+  const applicable = loadRules(rulesPath).filter((rule) => scope === 'any' || rule.scope.includes('any') || rule.scope.includes(scope));
+  const files = filesAt(paths);
+  const findings = files.flatMap((file) => findInFile(file, applicable, scope));
+  debug.log('brand.check', 'run', { scope, files: files.length, findings: findings.length, rules: applicable.length });
+  return { files: files.length, findings, rules: applicable.length, missing: false };
+}
+
+if (import.meta.main) {
+  try {
+    const args = process.argv.slice(2);
+    let scope: Scope | undefined;
+    let rulesPath = defaultRules;
+    let json = false;
+    const paths: string[] = [];
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i]!;
+      if (arg === '--scope') scope = args[++i] as Scope;
+      else if (arg === '--rules') rulesPath = args[++i] ?? '';
+      else if (arg === '--json') json = true;
+      else if (arg.startsWith('--')) throw new Error(`unknown option: ${arg}`);
+      else paths.push(arg);
+    }
+    if (!scope || !scopes.includes(scope) || !paths.length || !rulesPath) throw new Error('usage: bun scripts/brand/check.ts --scope <scope> <file|folder...> [--rules <path>] [--json]');
+    const result = checkBrand(scope, paths, rulesPath);
+    if (result.missing) console.log(json ? JSON.stringify({ ...result, message: '규칙 없음' }) : '규칙 없음');
+    else if (json) console.log(JSON.stringify({ scope, ...result }));
+    else {
+      for (const finding of result.findings) console.log(`${finding.file}:${finding.line}:${finding.id}:${finding.match}`);
+      console.log(`brand-check ${scope} files=${result.files} findings=${result.findings.length} rules=${result.rules}`);
+    }
+    if (result.findings.length) process.exitCode = 1;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 2;
+  }
+}

package/scripts/coord-post.sh

@@ -220,7 +220,17 @@ fi
 echo "[coord-post] 발신 성공$VIA · 채널 #$PR · 신원 [$ID] · 시각 $TS" >&2
 # Only a successfully sent post is recorded; never pass the body or later lines to the ledger.
 POST_URL=$(printf '%s\n' "$POST_OUTPUT" | grep -oE 'https://github\.com/[^[:space:]]+/issues/[0-9]+#issuecomment-[0-9]+|https://github\.com/[^[:space:]]+/pull/[0-9]+#issuecomment-[0-9]+' | head -1 || true)
-if ! bun bin/elanous.mjs coord event record --seat "$ID" --header "$(head -1 "$TMP")" --url "$POST_URL" >/dev/null 2>&1; then
+# The channel is a production surface, so its record belongs in the production ledger, not this tree's
+# test universe (OP 10-04 18:00). An explicit ELANOUS_STATE_DIR is the caller's chosen universe and wins;
+# otherwise prefer the installed CLI (resolves prod from any tree), else pin the source CLI to prod.
+if [ -n "${ELANOUS_STATE_DIR:-}" ]; then
+  RECORD=(bun bin/elanous.mjs coord event record)
+elif command -v eln >/dev/null 2>&1; then
+  RECORD=(eln coord event record)
+else
+  RECORD=(env ELANOUS_STATE_DIR="$HOME/.elanous" bun bin/elanous.mjs --config-dir "$HOME/.elanous" coord event record)
+fi
+if ! "${RECORD[@]}" --seat "$ID" --header "$(head -1 "$TMP")" --url "$POST_URL" >/dev/null 2>&1; then
   echo '⚠️ 맥락 원장 기록 실패(발신은 됐다)' >&2
 fi
 exit 0

package/scripts/docs-cli-check.ts

@@ -2,7 +2,7 @@
 // 공개 문서에 적힌 `elanous …` 명령·하위 명령·플래그가 «실제 CLI» 에 있나 — 문서가 실제와 어긋나는 1순위 원인을 잡는다.
 //   bun scripts/docs-cli-check.ts [--json] [files…]      (기본 = release/public/내부 문서 `*` ⊕ README.md)
 // 🩸 계기(2026-09-25 🅢 RFC 피드백 ③): README·install.md 가 거짓이 된 원인이 전부 «설치기·doctor 가 바뀌었는데 문서가 모름»이었다.
-// 자 = `bun bin/elanous.mjs <cmd> [<sub>] --help` 산출(원천) — 문서의 코드 블록과 인라인 코드에서 `elanous ` 로 시작하는 것만 본다.
+// 자 = `bun bin/elanous.mjs <cmd> [<sub>] [<subsub>] --help` 산출(원천) — 문서의 코드 블록과 인라인 코드에서 `elanous ` 로 시작하는 것만 본다.
 // ⛔ 못 본 것은 «없다»로 적지 않는다: `--help` 가 실패하면 그 명령은 `unmeasured` 로 따로 센다.
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
@@ -10,7 +10,7 @@ import { spawnSync } from 'node:child_process';
 
 const REPO = resolve(import.meta.dir, '..');
 
-export interface DocCommand { file: string; line: number; text: string; cmd: string; sub?: string; flags: string[] }
+export interface DocCommand { file: string; line: number; text: string; cmd: string; sub?: string; subsub?: string; flags: string[] }
 export interface Finding { kind: 'unknown-command' | 'unknown-subcommand' | 'unknown-flag' | 'unmeasured'; ref: DocCommand; detail: string }
 
 /** 코드 블록(``` … ```) 줄과 인라인 코드(`elanous …`)에서 elanous 호출을 뽑는다. 자리표(`<x>`)·셸 변수는 인자로 보고 넘긴다. */
@@ -24,15 +24,17 @@ export function extractElanousCommands(file: string, text: string): DocCommand[]
     for (const m of raw.matchAll(/`(elanous [^`]+)`/g)) candidates.push(m[1]!);
     for (const c of candidates) {
       for (const seg of c.split(/&&|\|\||;|\|/)) {
-        const m = /(?:^|\s)elanous\s+(.+)$/.exec(seg.trim());
+        const m = /^(?:(?:\$\s+|>\s+|sudo\s+|[A-Za-z_][A-Za-z0-9_]*=\S+\s+))*elanous\s+(.+)$/.exec(seg.trim());
         if (!m) continue;
         const tokens = m[1]!.trim().split(/\s+/).filter(Boolean);
         const cmd = tokens[0];
         if (!cmd || !/^[a-z][a-z0-9:-]*$/.test(cmd)) continue;
         const second = tokens[1];
         const sub = second && /^[a-z][a-z0-9-]*$/.test(second) ? second : undefined;
+        const third = tokens[2];
+        const subsub = sub && third && /^[a-z][a-z0-9-]*$/.test(third) ? third : undefined;
         const flags = tokens.filter((t) => /^--[a-z]/.test(t)).map((t) => t.replace(/[=,.)].*$/, ''));
-        out.push({ file, line: i + 1, text: seg.trim(), cmd, ...(sub ? { sub } : {}), flags });
+        out.push({ file, line: i + 1, text: seg.trim(), cmd, ...(sub ? { sub } : {}), ...(subsub ? { subsub } : {}), flags });
       }
     }
   });
@@ -63,13 +65,28 @@ export function checkCommands(refs: readonly DocCommand[], help: HelpRunner = de
     const cmdHelp = get([ref.cmd]);
     if (!cmdHelp.ok) { findings.push({ kind: 'unmeasured', ref, detail: `elanous ${ref.cmd} --help 실패` }); continue; }
     let flagsHelp = cmdHelp.out;
+    let flagsPath = `elanous ${ref.cmd}`;
     if (ref.sub && /\nCommands:\n/.test(cmdHelp.out)) {
       if (!listed(cmdHelp.out, ref.sub)) { findings.push({ kind: 'unknown-subcommand', ref, detail: `elanous ${ref.cmd} ${ref.sub}` }); continue; }
+      flagsPath = `elanous ${ref.cmd} ${ref.sub}`;
       const subHelp = get([ref.cmd, ref.sub]);
-      if (subHelp.ok) flagsHelp = subHelp.out;
+      if (!subHelp.ok) {
+        findings.push({ kind: 'unmeasured', ref, detail: `${flagsPath} --help 실패` });
+        continue;
+      }
+      flagsHelp = subHelp.out;
+      if (ref.subsub && listed(subHelp.out, ref.subsub)) {
+        flagsPath += ` ${ref.subsub}`;
+        const subsubHelp = get([ref.cmd, ref.sub, ref.subsub]);
+        if (!subsubHelp.ok) {
+          findings.push({ kind: 'unmeasured', ref, detail: `${flagsPath} --help 실패` });
+          continue;
+        }
+        flagsHelp = subsubHelp.out;
+      }
     }
     for (const f of ref.flags) {
-      if (!new RegExp(`(^|[\\s,])${f}(\\b|[\\s,=<\\[])`, 'm').test(flagsHelp)) findings.push({ kind: 'unknown-flag', ref, detail: `${f} (elanous ${ref.cmd}${ref.sub ? ` ${ref.sub}` : ''})` });
+      if (!new RegExp(`(^|[\\s,])${f}(\\b|[\\s,=<\\[])`, 'm').test(flagsHelp)) findings.push({ kind: 'unknown-flag', ref, detail: `${f} (${flagsPath})` });
     }
   }
   return findings;