ltcai 9.9.4 → 9.9.9

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.4",
+  "version": "9.9.9",
   "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": {
@@ -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",
@@ -41,6 +41,7 @@
     "test:integration": "node scripts/run_integration_tests.mjs",
     "test:browser-extension": "node --check browser-extension/popup.js && node --check browser-extension/capture-page.js && node --test tests/browser-extension.test.cjs",
     "test:visual": "playwright test",
+    "test:e2e:sidecar": "node scripts/run_sidecar_e2e.mjs",
     "vercel:build": "node scripts/build_vercel_static.mjs",
     "desktop:tauri": "tauri dev",
     "desktop:tauri:build": "tauri build",
@@ -56,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 = "Durable Loops";
+const releaseTheme = "Lean Shell";
 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/scripts/run_sidecar_e2e.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+/**
+ * Start an isolated Lattice sidecar and run Playwright first-value E2E
+ * against it (Wave 3.2 residual / v9.9.5).
+ *
+ * Mirrors scripts/run_integration_tests.mjs isolation rules: never touch
+ * the developer's real HOME / ~/.ltcai / Brain vault.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const host = process.env.LTCAI_E2E_HOST || "127.0.0.1";
+if (!new Set(["127.0.0.1", "localhost"]).has(host)) {
+  throw new Error(`LTCAI_E2E_HOST must be loopback, received: ${host}`);
+}
+const port = process.env.LTCAI_E2E_PORT || "4899";
+if (!/^\d+$/.test(port) || Number(port) < 1 || Number(port) > 65535) {
+  throw new Error(`LTCAI_E2E_PORT must be 1–65535, received: ${port}`);
+}
+const baseUrl = `http://${host}:${port}`;
+const venvPython = join(process.cwd(), ".venv", "bin", "python");
+const python = process.env.PYTHON || (existsSync(venvPython) ? venvPython : "python3");
+
+const sandboxRoot = mkdtempSync(join(tmpdir(), "ltcai-e2e-"));
+const sandbox = {
+  home: join(sandboxRoot, "home"),
+  data: join(sandboxRoot, "data"),
+  brain: join(sandboxRoot, "brain"),
+  agent: join(sandboxRoot, "agent-workspace"),
+  vault: join(sandboxRoot, "vault"),
+  cache: join(sandboxRoot, "cache"),
+  config: join(sandboxRoot, "config"),
+  tmp: join(sandboxRoot, "tmp"),
+};
+for (const path of Object.values(sandbox)) mkdirSync(path, { recursive: true });
+
+const isolatedEnv = {
+  ...process.env,
+  HOME: sandbox.home,
+  USERPROFILE: sandbox.home,
+  XDG_CACHE_HOME: sandbox.cache,
+  XDG_CONFIG_HOME: sandbox.config,
+  XDG_DATA_HOME: join(sandboxRoot, "share"),
+  TMPDIR: sandbox.tmp,
+  TEMP: sandbox.tmp,
+  TMP: sandbox.tmp,
+  LATTICEAI_MODE: "local",
+  LATTICEAI_HOST: host,
+  LATTICEAI_PORT: port,
+  LATTICEAI_DATA_DIR: sandbox.data,
+  LATTICEAI_BRAIN_DIR: sandbox.brain,
+  LATTICEAI_AGENT_ROOT: sandbox.agent,
+  LATTICEAI_OBSIDIAN_VAULT_DIR: sandbox.vault,
+  LATTICEAI_STORAGE_ENGINE: "sqlite",
+  LATTICEAI_POSTGRES_DSN: "",
+  LATTICEAI_REQUIRE_AUTH: "false",
+  LATTICEAI_ENABLE_TELEGRAM: "false",
+  LATTICEAI_AUTOLOAD_MODELS: "false",
+  LATTICEAI_ALLOW_MODEL_DOWNLOADS: "false",
+  LATTICEAI_AUTO_READ_CHAT_PATHS: "false",
+  LATTICEAI_TUNNEL: "false",
+  LATTICEAI_DISCORD_PERMISSION_WEBHOOK: "",
+  LATTICEAI_DISCORD_BOT_TOKEN: "",
+  OIDC_DISCOVERY_URL: "",
+  PYTHON_KEYRING_BACKEND: "keyring.backends.null.Keyring",
+  LTCAI_E2E_BASE_URL: baseUrl,
+};
+
+let sandboxCleaned = false;
+function cleanupSandbox() {
+  if (sandboxCleaned) return;
+  sandboxCleaned = true;
+  rmSync(sandboxRoot, { recursive: true, force: true });
+}
+process.once("exit", cleanupSandbox);
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForHealth(url, timeoutMs = 60000) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError = "";
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(`${url}/health`, { signal: AbortSignal.timeout(3000) });
+      if (response.ok) return;
+      lastError = `HTTP ${response.status}`;
+    } catch (error) {
+      lastError = String(error?.message || error);
+    }
+    await delay(500);
+  }
+  throw new Error(`Timed out waiting for ${url}/health: ${lastError}`);
+}
+
+function stop(child) {
+  return new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      resolve();
+      return;
+    }
+    const timer = setTimeout(() => {
+      if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+    }, 5000);
+    child.once("close", () => {
+      clearTimeout(timer);
+      resolve();
+    });
+    child.kill("SIGTERM");
+  });
+}
+
+async function main() {
+  console.log(`[e2e] sandbox ${sandboxRoot}`);
+  console.log(`[e2e] starting sidecar at ${baseUrl}`);
+  // Same process model as scripts/run_integration_tests.mjs: uvicorn on
+  // server:app with an isolated env. Do not double-append /health — the
+  // wait helper already probes `${url}/health`.
+  const server = spawn(
+    python,
+    ["-m", "uvicorn", "server:app", "--host", host, "--port", port],
+    { stdio: "inherit", env: isolatedEnv, cwd: process.cwd() },
+  );
+
+  let exitCode = 1;
+  try {
+    await waitForHealth(baseUrl);
+    console.log("[e2e] sidecar healthy — running Playwright");
+    // Playwright must use the host browser install (npx playwright install).
+    // The sidecar isolation rewrites HOME/XDG_* into a disposable sandbox —
+    // reusing that env here makes Chromium look under /tmp/.../ms-playwright
+    // and fail with "Executable doesn't exist".
+    const playwrightEnv = {
+      ...process.env,
+      LTCAI_E2E_BASE_URL: baseUrl,
+    };
+    const playwright = spawn(
+      "npx",
+      ["playwright", "test", "-c", "playwright.e2e.config.js"],
+      { stdio: "inherit", env: playwrightEnv, cwd: process.cwd() },
+    );
+    exitCode = await new Promise((resolve, reject) => {
+      playwright.on("error", reject);
+      playwright.on("close", (code) => resolve(code ?? 1));
+    });
+  } catch (error) {
+    console.error("[e2e] failed:", error);
+    exitCode = 1;
+  } finally {
+    await stop(server);
+    cleanupSandbox();
+  }
+  process.exit(exitCode);
+}
+
+main();

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` | 모델 미로드 | 모델을 먼저 로드 |