ltcai 9.9.5 → 10.0.0

package/latticeai/services/tool_dispatch.py

@@ -14,12 +14,19 @@ from typing import Any, Callable, Dict, Mapping, Optional
 from fastapi import HTTPException
 
 from latticeai.core.agent import AgentDeps, SingleAgentRuntime
+from latticeai.core.agent_permission import call_mode_source
 from latticeai.core.agent_prompts import (
     CRITIC_PROMPT,
     EXECUTOR_PROMPT,
     MEMORY_UPDATER_PROMPT,
     PLANNER_PROMPT,
 )
+from latticeai.core.permission_mode import (
+    DEFAULT_MODE,
+    effective_auto_approve,
+    is_circuit_breaker,
+    normalize_mode,
+)
 from latticeai.core.policy import role_has_capability
 from latticeai.core.tool_governor import classify_tool_call
 from latticeai.core.tool_registry import ToolPermission, ToolPolicy
@@ -34,6 +41,10 @@ def _default_get_user_role(_email, _users=None) -> str:
     return "user"
 
 
+def _default_permission_mode() -> Any:
+    return DEFAULT_MODE
+
+
 FILE_CREATE_ACTIONS = set(DEFAULT_TOOL_REGISTRY.file_create_actions)
 TOOL_GOVERNANCE: Dict[str, ToolPolicy] = dict(DEFAULT_TOOL_REGISTRY.governance)
 TOOL_GOVERNANCE_DEFAULT: ToolPolicy = DEFAULT_TOOL_REGISTRY.default_policy
@@ -62,6 +73,10 @@ class ToolDispatchService:
     registry: Any = field(default_factory=lambda: DEFAULT_TOOL_REGISTRY)
     load_users: Callable[[], Dict[str, Any]] = field(default=_default_load_users)
     get_user_role: Callable[..., str] = field(default=_default_get_user_role)
+    # Static mode, or a callable resolved per enforce_policy call. A callable
+    # may accept ``user_email``/``workspace_id`` scope kwargs (preferred) or no
+    # arguments at all — see ``call_mode_source``.
+    permission_mode: Any = field(default_factory=lambda: _default_permission_mode)
 
     @property
     def file_create_actions(self) -> frozenset[str]:
@@ -80,9 +95,29 @@ class ToolDispatchService:
         *,
         load_users: Callable[[], Dict[str, Any]],
         get_user_role: Callable[..., str],
+        permission_mode: Any = None,
     ) -> None:
         self.load_users = load_users
         self.get_user_role = get_user_role
+        if permission_mode is not None:
+            self.permission_mode = permission_mode
+
+    def resolve_permission_mode(
+        self,
+        *,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Any:
+        """Active autonomy dial for this caller.
+
+        The scope matters: per-user and per-workspace overrides are stored by
+        ``PermissionModeService``, so resolving without a scope would silently
+        collapse every caller onto the process-wide default.
+        """
+        raw = call_mode_source(
+            self.permission_mode, user_email=user_email, workspace_id=workspace_id,
+        )
+        return normalize_mode(raw if raw is not None else DEFAULT_MODE)
 
     def policy_for(self, action_name: str, args: dict) -> ToolPolicy:
         return self.registry.policy_for(action_name, args)
@@ -155,6 +190,8 @@ class ToolDispatchService:
         source: str,
         require_auto_approval: bool = True,
         trusted_admin: bool = False,
+        permission_mode: Any = None,
+        workspace_id: Optional[str] = None,
     ) -> ToolPolicy:
         """Authorize a tool call before any hook or handler can execute.
 
@@ -162,8 +199,18 @@ class ToolDispatchService:
         runtime uses the same policy data and blocks non-auto-approved steps in
         its state machine so Computer Use direct endpoints can remain unchanged
         when explicitly excluded from a hardening pass.
+
+        The active :class:`PermissionMode` widens what may run without an extra
+        approval prompt; it never widens a circuit breaker.
         """
         policy = self.policy_for(tool_name, args or {})
+        mode = normalize_mode(
+            permission_mode
+            if permission_mode is not None
+            else self.resolve_permission_mode(
+                user_email=current_user, workspace_id=workspace_id,
+            )
+        )
         if source in {"mcp", "plugin"} and tool_name in EXPLICIT_CONSENT_TOOLS:
             raise HTTPException(
                 status_code=403,
@@ -174,14 +221,22 @@ class ToolDispatchService:
             )
         if not trusted_admin:
             self.check_role(tool_name, current_user)
+
+        breaker = is_circuit_breaker(tool_name, policy, args or {})
+        if breaker:
+            raise HTTPException(status_code=403, detail=f"'{tool_name}' 차단: {breaker}")
+
         if policy["destructive"] or policy["risk"] == "destructive":
             raise HTTPException(
                 status_code=403,
                 detail=f"'{tool_name}' 툴은 파괴적 작업으로 차단되었습니다.",
             )
+
         # Fail-closed governance: a call that would rewrite existing content but
         # cannot be staged as a reviewable proposal is blocked, never applied
-        # silently. New-file (additive) calls are unaffected.
+        # silently. New-file (additive) calls are unaffected. This is
+        # mode-invariant — trusted/bypass skip *proposal staging*, but a binary
+        # overwrite has no safe apply path in any mode, so it stays blocked.
         verdict = classify_tool_call(
             tool_name, args or {},
             policy=dict(policy), path_exists=self._governed_path_exists,
@@ -195,17 +250,22 @@ class ToolDispatchService:
                     "지원되는 편집 도구(write_file/edit_file)를 사용하세요."
                 ),
             )
+
+        auto = policy["auto_approve"] or effective_auto_approve(
+            mode, tool_name, policy, change_class=verdict.get("change_class"), args=args or {},
+        )
         if (
             require_auto_approval
             and not trusted_admin
-            and not policy["auto_approve"]
+            and not auto
             and self.user_role(current_user) not in {"admin", "owner"}
         ):
             raise HTTPException(
                 status_code=403,
                 detail=(
-                    f"'{tool_name}' 툴은 명시 승인이 필요합니다. "
-                    "현재 릴리스에서는 승인 UI가 없는 직접 실행 경로에서 기본 차단됩니다."
+                    f"'{tool_name}' 툴은 명시 승인이 필요합니다 "
+                    f"(permission_mode={mode.value}). "
+                    "승인 UI가 없는 직접 실행 경로에서 차단되었습니다."
                 ),
             )
         return policy
@@ -282,10 +342,12 @@ def configure_tool_dispatch(
     *,
     load_users: Callable[[], Dict[str, Any]],
     get_user_role: Callable[..., str],
+    permission_mode: Any = None,
 ) -> None:
     DEFAULT_TOOL_DISPATCH_SERVICE.configure(
         load_users=load_users,
         get_user_role=get_user_role,
+        permission_mode=permission_mode,
     )
 
 
@@ -325,6 +387,8 @@ def enforce_tool_policy(
     source: str,
     require_auto_approval: bool = True,
     trusted_admin: bool = False,
+    permission_mode: Any = None,
+    workspace_id: Optional[str] = None,
 ) -> ToolPolicy:
     return DEFAULT_TOOL_DISPATCH_SERVICE.enforce_policy(
         tool_name,
@@ -333,6 +397,8 @@ def enforce_tool_policy(
         source=source,
         require_auto_approval=require_auto_approval,
         trusted_admin=trusted_admin,
+        workspace_id=workspace_id,
+        permission_mode=permission_mode,
     )
 
 
@@ -408,8 +474,10 @@ def build_agent_runtime(
     hooks: Any = None,
     brain_memory: Any = None,
     dispatch_service: ToolDispatchService = DEFAULT_TOOL_DISPATCH_SERVICE,
+    permission_mode: Any = None,
 ) -> SingleAgentRuntime:
     ensure_agent_root()
+    mode = permission_mode if permission_mode is not None else dispatch_service.permission_mode
     deps = AgentDeps(
         generate_as=model_router.generate_as,
         generate=model_router.generate,
@@ -433,6 +501,7 @@ def build_agent_runtime(
         restore_snapshot=dispatch_service.restore_snapshot,
         hooks=hooks,
         brain_memory=brain_memory,
+        permission_mode=mode,
     )
     return SingleAgentRuntime(deps)
 

package/latticeai/services/voice_capture.py

@@ -0,0 +1,189 @@
+"""Voice memo capture — the fastest path from a thought to the Brain (v9.9.7).
+
+Typing is the slowest part of capture. A 15-second voice memo on a phone or a
+laptop is the shortest distance between "I should remember this" and the Brain
+actually having it.
+
+The hard constraint is local-first: a voice memo must never leave the machine
+to become text. So transcription is an **injected, optional port**:
+
+* when a local transcriber is available, the memo is transcribed and ingested
+  exactly like a typed note — same pipeline, same provenance, same quality
+  signals;
+* when it is not, the audio is still stored and indexed by whatever the user
+  gave us (title, tags), and the result says ``transcription="unavailable"``
+  with the reason. **A missing transcriber never produces an invented
+  transcript**, and the memo is never silently dropped either.
+
+Nothing here reaches for a cloud speech API, and nothing here installs a model
+behind the user's back — an absent transcriber is a reported state, not a
+prompt to download something.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+LOGGER = logging.getLogger(__name__)
+
+__all__ = ["VoiceCaptureService", "TranscriptionUnavailable", "SUPPORTED_AUDIO_EXTENSIONS"]
+
+# Container formats a local transcriber can plausibly open. Anything else is
+# refused with a clear reason rather than handed to a transcriber that will
+# fail obscurely.
+SUPPORTED_AUDIO_EXTENSIONS = frozenset({
+    ".m4a", ".mp3", ".wav", ".aac", ".flac", ".ogg", ".webm", ".mp4",
+})
+
+# A memo is short by nature; a huge file is a recording session, not a memo,
+# and would block the request for minutes.
+MAX_AUDIO_BYTES = 50 * 1024 * 1024
+
+
+class TranscriptionUnavailable(RuntimeError):
+    """No local transcriber could turn this audio into text."""
+
+
+class VoiceCaptureService:
+    """Ingest a voice memo through the unified ingestion pipeline."""
+
+    def __init__(
+        self,
+        *,
+        pipeline: Any,
+        transcriber: Optional[Callable[[str], str]] = None,
+        max_bytes: int = MAX_AUDIO_BYTES,
+    ) -> None:
+        self._pipeline = pipeline
+        self._transcriber = transcriber
+        self._max_bytes = max(1, int(max_bytes))
+
+    # ── capability ───────────────────────────────────────────────────────
+    def status(self) -> Dict[str, Any]:
+        """What this install can actually do with a voice memo, honestly."""
+        return {
+            "capture": self._pipeline is not None,
+            "transcription": self._transcriber is not None,
+            "supported_extensions": sorted(SUPPORTED_AUDIO_EXTENSIONS),
+            "max_bytes": self._max_bytes,
+            "detail": (
+                "음성 메모를 글로 바꿔 Brain에 저장합니다."
+                if self._transcriber is not None
+                else "이 컴퓨터에는 음성 인식기가 없어서, 메모는 저장되지만 글로 바뀌지는 않습니다."
+            ),
+        }
+
+    # ── transcription ────────────────────────────────────────────────────
+    def _transcribe(self, path: Path) -> str:
+        if self._transcriber is None:
+            raise TranscriptionUnavailable("no local transcriber is configured")
+        text = self._transcriber(str(path))
+        cleaned = str(text or "").strip()
+        if not cleaned:
+            # An empty transcript is not text: reporting it as one would put an
+            # empty note in the Brain and call it a memory.
+            raise TranscriptionUnavailable("the transcriber returned no text")
+        return cleaned
+
+    # ── capture ──────────────────────────────────────────────────────────
+    def capture(
+        self,
+        audio_path: str,
+        *,
+        title: Optional[str] = None,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        conversation_id: Optional[str] = None,
+        transcript: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Ingest one voice memo.
+
+        ``transcript`` lets a client that already has text (a phone's own
+        dictation, for example) skip local transcription entirely — the memo
+        still lands in the Brain through the same pipeline.
+        """
+        from lattice_brain.ingestion import IngestionItem
+
+        path = Path(str(audio_path or "")).expanduser()
+        if not path.exists() or not path.is_file():
+            return self._failed("FILE_NOT_FOUND", f"audio file not found: {path}")
+        suffix = path.suffix.lower()
+        if suffix not in SUPPORTED_AUDIO_EXTENSIONS:
+            return self._failed(
+                "UNSUPPORTED_FORMAT",
+                f"{suffix or 'this file'} is not a supported audio container",
+            )
+        try:
+            size = path.stat().st_size
+        except OSError as exc:
+            return self._failed("FILE_NOT_FOUND", f"audio file unreadable: {exc}")
+        if size > self._max_bytes:
+            return self._failed(
+                "SIZE_LIMIT",
+                f"audio is {size} bytes; the memo limit is {self._max_bytes}",
+            )
+        if self._pipeline is None:
+            return self._failed("UNAVAILABLE", "the ingestion pipeline is not available")
+
+        supplied = str(transcript or "").strip()
+        transcription_state = "supplied" if supplied else "ok"
+        transcription_detail = ""
+        text = supplied
+        if not text:
+            try:
+                text = self._transcribe(path)
+            except TranscriptionUnavailable as exc:
+                transcription_state = "unavailable"
+                transcription_detail = str(exc)
+                text = ""
+            except Exception as exc:  # noqa: BLE001 — a broken transcriber is a state
+                LOGGER.exception("voice transcription failed")
+                transcription_state = "failed"
+                transcription_detail = str(exc)
+                text = ""
+
+        display_title = str(title or "").strip() or path.stem
+        # With no transcript there is no text to index — the memo is recorded
+        # by what we honestly know (title + the audio file itself), and the
+        # response says so. It is never presented as a searchable note.
+        body = text or (
+            f"[음성 메모] {display_title}\n"
+            "이 메모는 아직 글로 바뀌지 않았습니다 — 음성 인식기가 없어 내용 검색은 되지 않습니다."
+        )
+        item = IngestionItem(
+            source_type="note",
+            title=display_title,
+            text=body,
+            source_uri=str(path),
+            mime_type=f"audio/{suffix.lstrip('.')}",
+            owner=user_email,
+            workspace_id=workspace_id,
+            conversation_id=conversation_id,
+            metadata={
+                "capture": "voice",
+                "audio_path": str(path),
+                "audio_bytes": size,
+                "transcription": transcription_state,
+                **({"transcription_detail": transcription_detail} if transcription_detail else {}),
+            },
+        )
+        result = self._pipeline.ingest(item, user_email=user_email)
+        payload = result.as_dict() if hasattr(result, "as_dict") else dict(result)
+        payload["transcription"] = transcription_state
+        payload["searchable"] = bool(text)
+        if transcription_detail:
+            payload["transcription_detail"] = transcription_detail
+        return payload
+
+    @staticmethod
+    def _failed(error: str, message: str) -> Dict[str, Any]:
+        return {
+            "status": "failed",
+            "source_type": "note",
+            "error": error,
+            "message": message,
+            "transcription": "skipped",
+            "searchable": False,
+        }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "9.9.5",
+  "version": "10.0.0",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -16,7 +16,7 @@
   },
   "scripts": {
     "start": "LTCAI",
-    "dev": "python3 -m latticeai.cli.entrypoint --reload",
+    "dev": "node scripts/run_python.mjs -m latticeai.cli.entrypoint --reload",
     "build": "npm run build:assets && npm run build:python",
     "frontend:dev": "vite --host 127.0.0.1",
     "frontend:openapi": "node scripts/run_python.mjs scripts/export_openapi.py frontend/openapi.json && npx openapi-typescript frontend/openapi.json -o frontend/src/api/openapi.ts",
@@ -24,7 +24,7 @@
     "build:assets": "vite build && node scripts/build_frontend_assets.mjs",
     "build:python": "node scripts/run_python.mjs -m build",
     "check:python": "node scripts/run_python.mjs scripts/check_python.py",
-    "lint": "npm run lint:python && node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend && npm run frontend:openapi:check && node scripts/check_i18n_literals.mjs && npm run check:bundle && npm run check:legacy-debt && npm run test:browser-extension",
+    "lint": "npm run lint:python && node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend && npm run frontend:openapi:check && node scripts/check_i18n_literals.mjs && npm run check:i18n-namespaces && npm run check:bundle && npm run check:legacy-debt && npm run test:browser-extension && npm run test:vscode-extension",
     "check:legacy-debt": "node scripts/check_legacy_debt.mjs",
     "lint:python": "node scripts/run_python.mjs -m ruff check .",
     "lint:frontend": "node scripts/lint_frontend.mjs",
@@ -57,7 +57,9 @@
     "publish:pypi": "npm run build:python && node scripts/run_python.mjs -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl",
     "publish:vscode": "cd vscode-extension && npm run package:vsix && npm run publish:vscode",
     "publish:openvsx": "cd vscode-extension && npm run package:vsix && npm run publish:openvsx",
-    "publish:all": "npm run release:artifacts && npm run release:validate && npm publish ltcai-$npm_package_version.tgz --access public && node scripts/run_python.mjs -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl && cd vscode-extension && npm run publish:vscode && npm run publish:openvsx"
+    "publish:all": "npm run release:artifacts && npm run release:validate && npm publish ltcai-$npm_package_version.tgz --access public && node scripts/run_python.mjs -m twine upload --skip-existing dist/ltcai-$npm_package_version.tar.gz dist/ltcai-$npm_package_version-py3-none-any.whl && cd vscode-extension && npm run publish:vscode && npm run publish:openvsx",
+    "test:vscode-extension": "cd vscode-extension && npm run build && cd .. && node --test tests/vscode-extension.test.cjs",
+    "check:i18n-namespaces": "node scripts/check_i18n_namespace_coverage.mjs"
   },
   "keywords": [
     "ltcai",

package/scripts/check_bundle_budget.mjs

@@ -23,6 +23,17 @@ const manifestPath = join(outDir, "asset-manifest.json");
 // pre-split baseline (632.9 kB raw / ~180 kB gzip single chunk) to lock in the
 // code-splitting win and catch regressions that pull heavy code back onto the
 // first-paint path. Raise it only with a deliberate, reviewed reason.
+//
+// 9.9.8 raised this to 152 KiB because `frontend/src/i18n/*` was one synchronous
+// table, so every route's copy sat in the entry chunk and the tree had ~0.7 KiB
+// of headroom left. 9.9.9 fixed the cause instead: namespaces register on
+// import and each lazy route pulls only the copy it reads, which dropped the
+// initial closure from 150.0 KiB to ~99 KiB gzip. The ceiling is back at its
+// original 150 KiB with real headroom underneath it again.
+//
+// `scripts/check_i18n_namespace_coverage.mjs` guards the split — it fails if a
+// module reads a key whose namespace its chunk never imports, which would
+// otherwise render the raw key instead of translated text.
 const INITIAL_JS_GZIP_BUDGET = 153_600; // 150 KiB
 
 function build() {

package/scripts/check_current_release_docs.mjs

@@ -6,7 +6,7 @@ const root = process.cwd();
 const pkg = JSON.parse(readFileSync(path.join(root, "package.json"), "utf8"));
 const version = pkg.version;
 const releaseDir = `output/release/v${version}`;
-const releaseTheme = "Closed Gaps";
+const releaseTheme = "Plain Language";
 const title = `${version} — ${releaseTheme}`;
 const escapedVersion = version.replaceAll(".", "\\.");
 

package/scripts/check_i18n_namespace_coverage.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// Proves the lazy i18n split is safe.
+//
+// `frontend/src/i18n/*` used to be one synchronous table merged into the entry
+// chunk, so every route's copy sat on the first-paint path (~3,000 lines).
+// Namespaces now register themselves on import, and a route pulls the namespace
+// it needs into its own lazy chunk.
+//
+// The failure mode that buys is silent: a component reads a key whose namespace
+// its chunk never imported, `t()` falls through to returning the raw key, and
+// the UI renders "system.permission.title" instead of Korean text. No error, no
+// test failure unless that exact component is rendered in a test.
+//
+// So this check walks the real module graph. For each entry — the eager root
+// plus every React.lazy() boundary — it collects the static closure, every
+// `t(lang, "key")` used in it, and every i18n namespace it imports. A key whose
+// namespace is not reachable from that entry is an error.
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, dirname, resolve, relative } from "node:path";
+import process from "node:process";
+
+const repo = join(import.meta.dirname, "..");
+const src = join(repo, "frontend", "src");
+const i18nDir = join(src, "i18n");
+
+const NAMESPACES = readdirSync(i18nDir)
+  .filter((name) => name.endsWith(".ts"))
+  .map((name) => name.replace(/\.ts$/, ""))
+  .filter((name) => !["types", "registry"].includes(name));
+
+// key -> namespace that defines it
+const keyOwner = new Map();
+for (const ns of NAMESPACES) {
+  const text = readFileSync(join(i18nDir, `${ns}.ts`), "utf8");
+  for (const match of text.matchAll(/^\s+"([^"]+)":/gm)) keyOwner.set(match[1], ns);
+}
+
+// `shell` is registered by i18n.ts itself, so it is always available.
+const ALWAYS_AVAILABLE = new Set(["shell"]);
+
+const STATIC_IMPORT = /^\s*import\s+(?!type\s)([^;]*?)from\s+"([^"]+)"/gm;
+const BARE_IMPORT = /^\s*import\s+"([^"]+)"/gm;
+const LAZY_IMPORT = /import\(\s*"([^"]+)"\s*\)/g;
+const KEY_USE = /\bt\(\s*[A-Za-z_$][\w.$]*\s*,\s*"([^"]+)"/g;
+
+function resolveSpec(spec, importer) {
+  let base;
+  if (spec.startsWith("@/")) base = join(src, spec.slice(2));
+  else if (spec.startsWith(".")) base = resolve(dirname(importer), spec);
+  else return null;
+  for (const candidate of [`${base}.ts`, `${base}.tsx`, join(base, "index.ts"), join(base, "index.tsx")]) {
+    if (existsSync(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  return null;
+}
+
+function readModule(file) {
+  const raw = readFileSync(file, "utf8");
+  // Drop `import { type X }`-only specifiers: TypeScript elides them, so they
+  // are not runtime edges and must not count as namespace coverage.
+  const statics = [];
+  for (const match of raw.matchAll(STATIC_IMPORT)) {
+    const clause = match[1];
+    const named = clause.match(/\{([^}]*)\}/);
+    const onlyTypes = named && named[1].trim().length > 0
+      && named[1].split(",").every((part) => !part.trim() || part.trim().startsWith("type "))
+      && !/^\s*\w+\s*,/.test(clause);
+    if (!onlyTypes) statics.push(match[2]);
+  }
+  for (const match of raw.matchAll(BARE_IMPORT)) statics.push(match[1]);
+  return {
+    statics,
+    lazy: [...raw.matchAll(LAZY_IMPORT)].map((m) => m[1]),
+    keys: [...raw.matchAll(KEY_USE)].map((m) => m[1]),
+  };
+}
+
+const cache = new Map();
+function moduleInfo(file) {
+  if (!cache.has(file)) cache.set(file, readModule(file));
+  return cache.get(file);
+}
+
+/** Static closure of an entry, not crossing further lazy boundaries. */
+function closure(entry) {
+  const seen = new Set();
+  const stack = [entry];
+  const lazyEdges = new Set();
+  while (stack.length) {
+    const file = stack.pop();
+    if (seen.has(file) || !existsSync(file)) continue;
+    seen.add(file);
+    const info = moduleInfo(file);
+    for (const spec of info.lazy) {
+      const target = resolveSpec(spec, file);
+      if (target) lazyEdges.add(target);
+    }
+    for (const spec of info.statics) {
+      const target = resolveSpec(spec, file);
+      if (target) stack.push(target);
+    }
+  }
+  return { modules: seen, lazyEdges };
+}
+
+const root = join(src, "main.tsx");
+const entries = new Map([["<entry> main.tsx", root]]);
+const rootClosure = closure(root);
+for (const target of rootClosure.lazyEdges) {
+  entries.set(`<lazy> ${relative(src, target)}`, target);
+}
+
+const errors = [];
+for (const [label, entry] of entries) {
+  const { modules } = closure(entry);
+  const available = new Set(ALWAYS_AVAILABLE);
+  for (const file of modules) {
+    if (dirname(file) === i18nDir) {
+      const ns = relative(i18nDir, file).replace(/\.ts$/, "");
+      if (NAMESPACES.includes(ns)) available.add(ns);
+    }
+  }
+  for (const file of modules) {
+    if (dirname(file) === i18nDir) continue;
+    for (const key of moduleInfo(file).keys) {
+      const owner = keyOwner.get(key);
+      if (!owner) {
+        errors.push(`${label}: ${relative(src, file)} uses unknown key "${key}"`);
+      } else if (!available.has(owner)) {
+        errors.push(
+          `${label}: ${relative(src, file)} uses "${key}" from the "${owner}" namespace, `
+          + `which this chunk never imports (add: import "@/i18n/${owner}";)`,
+        );
+      }
+    }
+  }
+}
+
+if (errors.length) {
+  console.error("i18n namespace coverage check failed:");
+  for (const error of [...new Set(errors)].sort()) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+console.log(
+  `i18n namespace coverage: ${entries.size} entry chunk(s) verified against `
+  + `${NAMESPACES.length} namespaces (${keyOwner.size} keys).`,
+);

package/skills/meeting_notes/SKILL.md

@@ -0,0 +1,82 @@
+# Skill: meeting_notes
+
+description: 회의록·메모에서 결정사항과 할 일을 뽑아 정리된 노트 파일로 저장한다.
+
+## 메타데이터
+- **버전**: 1.0.0
+- **카테고리**: document
+- **위험도**: low
+- **필요 권한**: workspace_write
+
+## 설명
+
+붙여넣은 회의 메모(또는 워크스페이스의 메모 파일)를 읽어 **결정사항 / 할 일 /
+미해결 질문**으로 갈라 정리하고, 워크스페이스에 마크다운 노트 한 장으로
+저장한다. 저장된 파일은 다른 생성물과 동일하게 Brain에 수집되므로, 다음 주에
+"지난 회의에서 뭘 정하기로 했지?"라고 물으면 근거와 함께 답이 나온다.
+
+이 스킬이 "설치하자마자 값이 보이는" 이유: 입력이 사람이 이미 가지고 있는
+것(회의 메모)이고, 출력이 사람이 이미 원하던 것(할 일 목록)이며, 중간에
+설정할 것이 없다.
+
+## 거버넌스
+
+`risk.json` 참고. 요약: `risk=write`, `destructive=false`, `shell=false`,
+`network=false`, `auto_approve=true`, `sandbox=workspace`, `rollback=snapshot`.
+
+새 파일 생성은 additive라 바로 실행되고, **기존 파일을 덮어쓰는 경우에는
+ChangeGovernor가 변경 제안으로 돌린다** — 승인 전에는 디스크가 바뀌지 않는다.
+
+## 트리거 조건
+
+호출해야 하는 상황:
+- "회의록 정리해줘", "이 메모에서 할 일만 뽑아줘"
+- 통화/미팅 직후 메모를 붙여넣었을 때
+- 주간 회의 노트를 매번 같은 형식으로 남기고 싶을 때
+
+호출하면 **안** 되는 상황:
+- 문서 전체 요약이 목적일 때 → `summarize_document`
+- 코드 리뷰 → `code_review`
+- 표/수치 분석 → `data_analysis`
+
+## Side Effects
+
+| 항목 | 내용 |
+|------|------|
+| 파일 변경 | 대상 경로에 마크다운 1개 생성 (기존 파일이면 변경 제안) |
+| 생성 파일 | `notes/<slug>.md` (기본) |
+| 프로세스 | 없음 |
+| 네트워크 | 없음 |
+
+## Rollback
+
+`rollback=snapshot`. 실행 실패 시 쓰기 전 스냅샷으로 복구하며, 이 실행이 새로
+만든 파일은 삭제된다.
+
+## 입력/출력 스키마
+
+`schema.json` 참고.
+
+## 실행 조건
+
+- LLM 모델이 로드되어 있어야 함
+- `notes` 텍스트 또는 읽을 수 있는 `source_path` 중 하나는 필수
+
+## 정직성 규칙
+
+- 메모에 없는 결정/할 일을 **만들어 내지 않는다.** 근거 문장이 없으면 그 항목은
+  넣지 않는다.
+- 담당자·기한이 적혀 있지 않으면 비워 둔다. 추측해서 채우지 않는다.
+- 결정사항이 하나도 없으면 "결정된 사항 없음"이라고 그대로 적는다.
+
+## 예제
+
+`examples.md` 참고.
+
+## 실패 처리
+
+| 에러 코드 | 원인 | 처리 방법 |
+|-----------|------|-----------|
+| `INVALID_INPUT` | notes와 source_path가 모두 없음 | 둘 중 하나 제공 |
+| `FILE_NOT_FOUND` | source_path 없음 | 경로 확인 |
+| `MODEL_NOT_LOADED` | 모델 미로드 | 모델을 먼저 로드 |