elanous 0.2.12 → 0.2.14

package/graphs/orchestrator/orchestrator.yaml

@@ -0,0 +1,59 @@
+graph_id: orchestrator
+loop:
+  title: 오케스트레이터
+  trigger:
+    cron: '0 8,12,18 * * *'
+    events: [manual]
+version: 1
+entry_node: intake
+terminal_nodes: [done, failed]
+nodes:
+  - node_id: intake
+    kind: agent
+    recipe: cmd:orchestrator-intake
+    max_visits: 1
+  - node_id: split
+    kind: agent
+    recipe: cmd:orchestrator-split
+    max_visits: 1
+  - node_id: place
+    kind: agent
+    recipe: cmd:orchestrator-place
+    max_visits: 1
+  - node_id: delegate
+    kind: agent
+    recipe: cmd:orchestrator-delegate
+    max_visits: 1
+  - node_id: reconcile
+    kind: agent
+    recipe: cmd:orchestrator-reconcile
+    max_visits: 1
+  - node_id: report
+    kind: agent
+    recipe: cmd:orchestrator-report
+    max_visits: 1
+  - node_id: done
+    kind: gate
+    max_visits: 1
+  - node_id: failed
+    kind: gate
+    max_visits: 1
+edges:
+  - from: intake
+    on: outcome
+    map: { ok: split, fail: failed }
+  - from: split
+    on: outcome
+    map: { ok: place, fail: failed }
+  - from: place
+    on: outcome
+    map: { ok: delegate, fail: failed }
+  - from: delegate
+    on: outcome
+    map: { ok: reconcile, fail: failed }
+  - from: reconcile
+    on: outcome
+    map: { ok: report, fail: failed }
+  - from: report
+    on: outcome
+    map: { ok: done, fail: failed }

package/graphs/orchestrator/recipes.yaml

@@ -0,0 +1,18 @@
+orchestrator-intake:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../src/loops/orchestrator/tick.ts" intake'
+  timeout_ms: 120000
+orchestrator-split:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../src/loops/orchestrator/tick.ts" split'
+  timeout_ms: 120000
+orchestrator-place:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../src/loops/orchestrator/tick.ts" place'
+  timeout_ms: 120000
+orchestrator-delegate:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../src/loops/orchestrator/tick.ts" delegate'
+  timeout_ms: 120000
+orchestrator-reconcile:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../src/loops/orchestrator/tick.ts" reconcile'
+  timeout_ms: 120000
+orchestrator-report:
+  command: 'bun "$ELANOUS_GRAPH_DIR/../../src/loops/orchestrator/tick.ts" report'
+  timeout_ms: 120000

package/graphs/release/recipes.yaml

@@ -56,6 +56,9 @@ docs-land:
 verify:
   command: 'bun scripts/release-loop/verify-node.ts'
   timeout_ms: 1800000
+vault-note:
+  command: 'bun scripts/release-loop/vault-note-node.ts'
+  timeout_ms: 60000
 ops-upgrade:
   command: 'bun scripts/release-loop/ops-upgrade-node.ts'
   timeout_ms: 1200000

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.12",
+  "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",
@@ -31,6 +31,7 @@
     "catalog/",
     "personas/",
     "persona-presets/",
+    "examples/teams/",
     "graphs/",
     "apps/pwa/out/",
     ".python-version",

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/context-hooks/emit.ts

@@ -1,24 +1,46 @@
+// Bounded Claude Code hook extractor: only seat folders (marked by `.claude/seat`) emit, and only fixed metadata.
 import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, isAbsolute, join } from 'node:path';
+
+const SEATS = new Set(['OP', 'TC', 'MK', 'UX']);
+const MAX_LEVELS = 6;
+
+// Walks up from the session cwd to the git root (or MAX_LEVELS); no or invalid marker → null.
+function findSeat(start: string): string | null {
+  let dir = start;
+  for (let level = 0; level <= MAX_LEVELS; level++) {
+    const marker = join(dir, '.claude', 'seat');
+    if (existsSync(marker)) {
+      const seat = readFileSync(marker, 'utf8').trim();
+      return SEATS.has(seat) ? seat : null;
+    }
+    if (existsSync(join(dir, '.git'))) return null;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
 
 const event = process.argv[2];
 if (event !== 'stop' && event !== 'post-tool-use') process.exit(0);
-
 try {
   const payload = JSON.parse(await Bun.stdin.text()) as Record<string, unknown>;
-  // A locator is useful only when it is a session ID, not arbitrary hook input.
   const session = payload.session_id;
   if (typeof session !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(session)) process.exit(0);
+  const cwd = typeof payload.cwd === 'string' && isAbsolute(payload.cwd) ? payload.cwd : process.cwd();
+  const seat = findSeat(cwd);
+  if (seat === null) process.exit(0);
+  if (event === 'stop') {
+    spawnSync('elanous', ['context', 'emit', 'task-done', '--seat', seat, '--text', 'Claude Code session stopped', '--ref', session],
+      { stdio: 'ignore', timeout: 3000 });
+    process.exit(0);
+  }
   const tool = payload.tool_name;
-  if (event === 'post-tool-use' && (typeof tool !== 'string' || !/^[a-z][a-z0-9_.:-]{0,63}$/i.test(tool))) process.exit(0);
-  // Only known tool identifiers can appear in the generated summary. Never copy hook free text.
-  const knownTools = new Set(['Read', 'Write', 'Edit', 'MultiEdit', 'Bash', 'Glob', 'Grep', 'LS',
-    'Task', 'WebFetch', 'WebSearch', 'NotebookEdit', 'TodoWrite', 'AskUserQuestion']);
-  const summary = event === 'stop' ? 'Claude Code session stopped'
-    : `Claude Code tool ${knownTools.has(tool as string) ? tool : 'other'} completed`;
+  if (typeof tool !== 'string' || !/^[a-z][a-z0-9_.:-]{0,63}$/i.test(tool)) process.exit(0);
+  const knownTools = new Set(['Read', 'Write', 'Edit', 'MultiEdit', 'Bash', 'Glob', 'Grep', 'LS', 'Task', 'WebFetch', 'WebSearch', 'NotebookEdit', 'TodoWrite', 'AskUserQuestion']);
+  const summary = `Claude Code tool ${knownTools.has(tool) ? tool : 'other'} completed`;
   const source = `elanous://context/claude-code/${session}`;
-  spawnSync('elanous', ['context', 'emit', '--kind', 'done', '--summary', summary, '--source', source], {
-    stdio: 'ignore', timeout: 3000,
-  });
-} catch {
-  // Hooks must not interrupt the seat session on malformed input or unavailable CLI.
-}
+  spawnSync('elanous', ['context', 'emit', '--kind', 'done', '--summary', summary, '--source', source], { stdio: 'ignore', timeout: 3000 });
+} catch { /* never interrupt the seat session */ }