ltcai 11.9.0 → 12.0.0

package/latticeai/runtime/brain_runtime.py

@@ -13,7 +13,16 @@ was requested.
 
 from __future__ import annotations
 
-from typing import Any, Callable, Mapping
+from typing import Any, Callable, Mapping, Optional, Tuple
+
+from latticeai.core.embedding_providers.autodetect import (
+    AUTO_PROVIDER,
+    Detection,
+    detect_embedder,
+    resolve_auto_provider,
+)
+
+_FALLBACK_NAMES = {"", "hash", "local", "fallback"}
 
 
 def build_embedder_runtime(
@@ -21,16 +30,26 @@ def build_embedder_runtime(
     config: Any,
     profile: Mapping[str, Any],
     resolve_embedder: Callable[..., Any],
+    detect: Optional[Callable[..., Detection]] = None,
 ) -> Any:
-    """Resolve the configured embedding provider once."""
+    """Resolve the configured embedding provider once.
 
-    provider = config.embedding_provider
-    model = config.embedding_model or str(profile.get("model") or "")
-    dim = config.embedding_dim or int(profile.get("dimensions") or 0)
-    if config.embedding_profile and provider in {"", "hash", "local", "fallback"}:
-        provider = str(profile.get("provider") or provider)
+    The resolution order is the product's, unchanged, with one addition at the
+    end: detection. What is on this machine is *always* looked up (so
+    ``GET /api/embeddings/status`` can say "a real embedder is right there"),
+    and it changes the resolution only when the operator asked for it with
+    ``LATTICEAI_EMBEDDING_PROVIDER=auto``. The finding rides back on the
+    resolved object as ``detected`` — an added attribute, so every existing
+    reader of ``ResolvedEmbedder`` is untouched.
+    """
+
+    provider, model, dim = _configured(config, profile)
+    detection = (detect or detect_embedder)(
+        configured_provider=provider, configured_model=model
+    )
+    provider, model, dim = resolve_auto_provider(provider, model, dim, detection)
 
-    return resolve_embedder(
+    resolved = resolve_embedder(
         provider,
         model=model,
         base_url=config.embedding_base_url,
@@ -38,8 +57,23 @@ def build_embedder_runtime(
         dim=dim,
         timeout=config.embedding_timeout,
         extra={"target": config.embedding_custom_target},
-        probe=provider not in {"", "hash", "local", "fallback"},
+        probe=provider not in _FALLBACK_NAMES,
     )
+    try:
+        resolved.detected = detection
+    except AttributeError:  # pragma: no cover - a stand-in without __dict__
+        pass
+    return resolved
+
+
+def _configured(config: Any, profile: Mapping[str, Any]) -> Tuple[str, str, int]:
+    """``(provider, model, dim)`` from configuration and the named profile."""
+    provider = config.embedding_provider
+    model = config.embedding_model or str(profile.get("model") or "")
+    dim = config.embedding_dim or int(profile.get("dimensions") or 0)
+    if config.embedding_profile and provider in _FALLBACK_NAMES | {AUTO_PROVIDER}:
+        provider = str(profile.get("provider") or provider)
+    return provider, model, dim
 
 
 __all__ = ["build_embedder_runtime"]

package/latticeai/runtime/build_phases/worker_profile.py

@@ -86,10 +86,11 @@ WORKER_SEAM_ROUTES: Tuple[Tuple[str, str], ...] = (
 #: The pure-compute seams of Wave 2.5 §W2 (``latticeai/api/worker_compute.py``).
 #: Kept apart from :data:`WORKER_SEAM_ROUTES` because they age in the opposite
 #: direction: the state seams above are retired once §W3 lands the native write
-#: engine, while these eight are what the worker is *for* once Rust owns every
-#: write. Mounted here and nowhere else. ``/worker/multimodal/describe`` was the
-#: ninth until v11.8.0 — it described an image for a native image ingest that
-#: was never built, and no caller ever appeared.
+#: engine, while these nine are what the worker is *for* once Rust owns every
+#: write. Mounted here and nowhere else. ``/worker/multimodal/describe`` was
+#: here until v11.8.0 — it described an image for a native image ingest that
+#: was never built. ``/worker/vector/query`` is the HNSW sidecar door
+#: (v12.0.0): approximate candidates, exact rescore in lattice-retrieval.
 WORKER_COMPUTE_ROUTES: Tuple[Tuple[str, str], ...] = (
     ("POST", "/worker/embed"),
     ("POST", "/worker/parse"),
@@ -99,6 +100,7 @@ WORKER_COMPUTE_ROUTES: Tuple[Tuple[str, str], ...] = (
     ("POST", "/worker/render/pdf"),
     ("POST", "/worker/asr"),
     ("POST", "/worker/extract"),
+    ("POST", "/worker/vector/query"),
 )
 
 
@@ -147,12 +149,19 @@ def phase_worker_routes(ctx: Any) -> None:
     # ``getattr`` because a worker built without a Brain still boots — each seam
     # reports the absence rather than failing construction.
     ports = getattr(ctx, "MULTIMODAL_PORTS", None)
+    data_dir = getattr(ctx, "DATA_DIR", None)
+    db_path = None
+    if data_dir is not None:
+        from pathlib import Path
+
+        db_path = Path(data_dir) / "knowledge_graph.sqlite"
     app.include_router(
         create_worker_compute_router(
             embedder=getattr(ctx, "EMBEDDER", None),
             transcriber=getattr(ports, "transcriber", None),
             require_user=ctx.require_user,
             enforce_rate_limit=ctx.enforce_rate_limit,
+            db_path=db_path,
         )
     )
     apply_worker_route_filter(app)

package/latticeai/services/architecture_readiness.py

@@ -19,7 +19,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-ARCHITECTURE_VERSION_TARGET = "11.9.0"
+ARCHITECTURE_VERSION_TARGET = "12.0.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",
@@ -177,7 +177,7 @@ def architecture_readiness(root: Path | None = None) -> Dict[str, Any]:
                 and not agent_alias_forbidden
             ) else "incomplete",
             evidence=[
-                "rust/lattice-agent/src/permission.rs block_reason_for_tool (native owner)",
+                "rust/lattice-agent/src/kernel/permission.rs block_reason_for_tool (native owner)",
                 "latticeai.api.agent_worker_seam.create_agent_worker_seam_router",
                 "tests/unit/test_agent_worker_seam.py",
             ],

package/latticeai/services/product_readiness.py

@@ -13,6 +13,11 @@ generator whose subject is now native: they point at the cargo test or the
 committed golden that actually guards the behaviour. The assertions themselves
 were not deleted — an evidence path is repointed at the owner or it is a gate
 that has stopped meaning anything.
+
+12.0.0 regrouped the Rust crates into domain directories, so four needles that
+named a top-level file in ``rust/lattice-agent/src/`` now name the same symbol
+in ``src/kernel/``. The needle text is unchanged — only the path moved, and
+each one was re-checked against the file it now names rather than assumed.
 """
 
 from __future__ import annotations
@@ -23,7 +28,7 @@ from typing import Any, Dict, List
 
 from latticeai.services.architecture_readiness import architecture_readiness
 
-PRODUCT_VERSION_TARGET = "11.9.0"
+PRODUCT_VERSION_TARGET = "12.0.0"
 
 
 @dataclass(frozen=True)
@@ -74,7 +79,7 @@ PRODUCT_GATES: List[ProductGate] = [
             "latticeai/tools/documents.py::read_document",
             "latticeai/tools/filesystem.py::read_file",
             "latticeai/core/tool_governor.py::classify_tool_call",
-            "rust/lattice-agent/src/permission.rs::pub fn block_reason_for_tool",
+            "rust/lattice-agent/src/kernel/permission.rs::pub fn block_reason_for_tool",
             "tests/unit/test_worker_compute.py::test_the_docx_bytes_open_as_a_document_with_the_blocks_that_were_sent",
             "tests/unit/test_tool_registry.py::test_execute_tool_uses_registry",
         ],
@@ -119,10 +124,10 @@ PRODUCT_GATES: List[ProductGate] = [
             f"docs/CHANGELOG.md::## [{PRODUCT_VERSION_TARGET}]",
             "FEATURE_STATUS.md",
             f"RELEASE_NOTES_v{PRODUCT_VERSION_TARGET}.md",
-            "rust/lattice-agent/src/permission.rs::pub fn block_reason_for_tool",
-            "rust/lattice-agent/src/lib.rs::pub mod agentloop",
+            "rust/lattice-agent/src/kernel/permission.rs::pub fn block_reason_for_tool",
+            "rust/lattice-agent/src/kernel/mod.rs::pub mod agentloop",
             "latticeai/api/agent_worker_seam.py::create_agent_worker_seam_router",
-            "rust/lattice-agent/src/permission.rs::pub fn non_auto_plan_steps",
+            "rust/lattice-agent/src/kernel/permission.rs::pub fn non_auto_plan_steps",
             "latticeai/worker_app.py::create_worker_app",
             "latticeai/worker_app.py::def create_worker_app",
             "latticeai/services/architecture_readiness.py::lattice-architecture-contract/v1",

package/latticeai/services/search_service.py

@@ -84,6 +84,13 @@ class SearchService:
             "state": state,
             "fell_back": fell_back,
             "health": health,
+            # v12.0.0, additive: is what this worker embeds with *semantic*, and
+            # if not, is a real embedder already sitting on the disk? The hash
+            # fallback is honest about being a fallback but said nothing about
+            # what it could have been, so nobody ever switched.
+            "semantic": grade != "fallback",
+            "detected": dict(resolved.get("detected") or {}),
+            "identity": f"{meta.get('model_id')}:{meta.get('dim')}",
             "detail": resolved.get("detail", ""),
             # Index completeness is native (lattice-jobs). Present and empty:
             # a reader learns this answer does not speak for the index, which

package/latticeai/tools/__init__.py

@@ -116,7 +116,12 @@ _CJK_FONT_CANDIDATES = [
     "/usr/share/fonts/truetype/nanum/NanumGothic.ttf",
 ]
 
-_SUPPORTED_READ_EXTENSIONS = {".pdf", ".docx", ".xlsx", ".pptx", ".txt", ".md", ".csv"}
+# `.html`/`.htm` joined in v12.0.0: they were classified as *code* and read
+# verbatim, so the graph stored markup instead of what the page says. See
+# `latticeai.tools.markup.html_to_text`.
+_SUPPORTED_READ_EXTENSIONS = {
+    ".pdf", ".docx", ".xlsx", ".pptx", ".txt", ".md", ".csv", ".html", ".htm",
+}
 DOCUMENT_MAX_READ_BYTES = 10_000_000  # 10 MB
 
 

package/latticeai/tools/documents.py

@@ -128,6 +128,18 @@ def read_document(path: str) -> Dict[str, Any]:
         except Exception as exc:
             raise ToolError(f"PPTX 읽기 실패: {exc}") from exc
 
+    elif ext in {".html", ".htm"}:
+        # A web page read verbatim is markup, not text: the graph filled up
+        # with `<div class=…>` and the contents of every `<script>`. The
+        # conversion keeps the page's headings as `#` lines so a fact
+        # extracted from it can still say which section it came from.
+        try:
+            from latticeai.tools.markup import html_to_text
+
+            text = html_to_text(target.read_text(encoding="utf-8", errors="replace"))
+        except Exception as exc:
+            raise ToolError(f"HTML 읽기 실패: {exc}") from exc
+
     elif ext in {".txt", ".md", ".csv"}:
         try:
             text = target.read_text(encoding="utf-8", errors="replace")

package/latticeai/tools/markup.py

@@ -0,0 +1,152 @@
+"""HTML → readable text, with the document's own structure kept.
+
+Until v12.0.0 an ``.html`` file was classified as *code* and read verbatim, so
+what reached the graph was `<div class="wrapper">` and the contents of every
+`<script>` tag. Chunks were markup, concepts were attribute names, and a search
+for a sentence on the page could not find the page.
+
+The conversion is deliberately small and dependency-free (``html.parser`` and
+``html.unescape`` are stdlib; adding BeautifulSoup for this would be a new
+runtime dependency for a hundred lines of tag handling):
+
+* ``<script>``, ``<style>``, ``<noscript>``, ``<template>`` and everything in
+  ``<head>`` except ``<title>`` are dropped — they are not what the page says;
+* ``<h1>``–``<h6>`` become markdown headings, so the section machinery in
+  :mod:`lattice_brain.graph._kg_common.sections` gives every extracted fact the
+  heading it lived under, exactly as it does for a ``.md`` file;
+* ``<li>`` becomes ``- ``, table cells are tab-separated, and block elements
+  end a line, so paragraph and list boundaries survive into chunking;
+* entities are unescaped once, at the end of each text run.
+
+The output is plain text that happens to carry markdown headings. It is *not*
+a markdown converter and does not try to be: bold, links and images are read
+for their text, because a knowledge graph wants the sentence, not the styling.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from html import unescape
+from html.parser import HTMLParser
+from typing import List, Set
+
+#: Elements whose *content* is never page text.
+SKIPPED_ELEMENTS: Set[str] = {"script", "style", "noscript", "template", "svg"}
+#: Elements that end the current line.
+BLOCK_ELEMENTS: Set[str] = {
+    "p", "div", "section", "article", "header", "footer", "nav", "aside",
+    "main", "ul", "ol", "li", "table", "tr", "blockquote", "pre", "form",
+    "figure", "figcaption", "dl", "dt", "dd", "hr", "br", "h1", "h2", "h3",
+    "h4", "h5", "h6", "title",
+}
+#: Elements that separate cells with a tab rather than a newline.
+CELL_ELEMENTS: Set[str] = {"td", "th"}
+
+_HEADINGS = {f"h{level}": level for level in range(1, 7)}
+_BLANK_RUN = re.compile(r"\n{3,}")
+_TRAILING_SPACE = re.compile(r"[ \t]+\n")
+
+
+class _TextExtractor(HTMLParser):
+    """Collect a page's readable text, marking its headings."""
+
+    def __init__(self) -> None:
+        super().__init__(convert_charrefs=False)
+        self.parts: List[str] = []
+        self._skip_depth = 0
+        self._heading: int = 0
+        self._in_head = False
+
+    # ── structure ────────────────────────────────────────────────────────
+    def handle_starttag(self, tag: str, attrs: object) -> None:
+        if tag in SKIPPED_ELEMENTS:
+            self._skip_depth += 1
+            return
+        if tag == "head":
+            self._in_head = True
+            return
+        if self._skip_depth:
+            return
+        level = _HEADINGS.get(tag)
+        # `<title>` is the page's name; treat it as the top heading so the
+        # section path of a page with no `<h1>` is still its own title.
+        if tag == "title":
+            level = 1
+        if level:
+            self._heading = level
+            self.parts.append("\n\n" + "#" * level + " ")
+            return
+        if tag == "li":
+            self.parts.append("\n- ")
+        elif tag in CELL_ELEMENTS:
+            self.parts.append("\t")
+        elif tag in BLOCK_ELEMENTS:
+            self.parts.append("\n")
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in SKIPPED_ELEMENTS:
+            self._skip_depth = max(0, self._skip_depth - 1)
+            return
+        if tag == "head":
+            self._in_head = False
+            return
+        if self._skip_depth:
+            return
+        if tag in _HEADINGS or tag == "title":
+            self._heading = 0
+            self.parts.append("\n\n")
+        elif tag == "li":
+            # `<li>` already opens its own line; closing one too would put a
+            # blank line between every bullet and turn a list into a page.
+            return
+        elif tag in BLOCK_ELEMENTS:
+            self.parts.append("\n")
+
+    # ── text ─────────────────────────────────────────────────────────────
+    def handle_data(self, data: str) -> None:
+        if self._skip_depth:
+            return
+        # Inside `<head>`, only `<title>` text is page content; `<meta>` and
+        # friends carry no data, but stray whitespace and CDATA do.
+        if self._in_head and not self._heading:
+            return
+        text = unescape(data)
+        if self._heading:
+            # A heading must stay on one line or it stops being a heading.
+            text = " ".join(text.split())
+            if text:
+                self.parts.append(text)
+            return
+        cleaned = re.sub(r"[ \t\r\f\v]+", " ", text.replace("\n", " "))
+        if cleaned.strip():
+            self.parts.append(cleaned)
+        elif cleaned:
+            self.parts.append(" ")
+
+    def handle_entityref(self, name: str) -> None:
+        self.handle_data(f"&{name};")
+
+    def handle_charref(self, name: str) -> None:
+        self.handle_data(f"&#{name};")
+
+
+def html_to_text(markup: str) -> str:
+    """Readable text for ``markup``, with headings kept as ``#`` lines.
+
+    Never raises: a truncated or malformed page yields whatever text was
+    recoverable, because half a document in the graph beats a failed ingest.
+    """
+    extractor = _TextExtractor()
+    try:
+        extractor.feed(str(markup or ""))
+        extractor.close()
+    except Exception as exc:  # pragma: no cover - html.parser is very tolerant
+        logging.debug("HTML parse stopped early; keeping what was read: %s", exc)
+    text = "".join(extractor.parts)
+    text = _TRAILING_SPACE.sub("\n", text)
+    text = _BLANK_RUN.sub("\n\n", text)
+    return "\n".join(line.rstrip() for line in text.split("\n")).strip()
+
+
+__all__ = ["BLOCK_ELEMENTS", "CELL_ELEMENTS", "SKIPPED_ELEMENTS", "html_to_text"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "11.9.0",
+  "version": "12.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": {
@@ -57,6 +57,7 @@
     "release:artifacts": "node scripts/clean_release_artifacts.mjs $npm_package_version && npm run build:assets && npm run build:python && npm pack && npm run package:vsix && npm run desktop:tauri:build",
     "release:validate": "node scripts/run_python.mjs scripts/validate_release_artifacts.py $npm_package_version --require-vsix --require-tgz --require-dmg",
     "release:smoke": "node scripts/run_python.mjs scripts/release_smoke.py $npm_package_version",
+    "publish:release": "node scripts/publish_release.mjs",
     "publish:npm": "npm pack && npm publish ltcai-$npm_package_version.tgz --access public",
     "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",

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 = "Working Order";
+const releaseTheme = "Open House";
 const title = `${version} — ${releaseTheme}`;
 const escapedVersion = version.replaceAll(".", "\\.");
 

package/scripts/compose_openapi.py

@@ -122,6 +122,8 @@ INTERNAL_WORKER_PATHS = frozenset(
         # ``/worker/multimodal/describe`` was here until v11.8.0 deleted the
         # seam: it described an image for a native ingest nothing ever built.
         "/worker/extract",
+        # v12.0.0 — HNSW sidecar query. Same loopback-only reasoning.
+        "/worker/vector/query",
     }
 )
 

package/scripts/openapi_route_families.json

@@ -18,8 +18,8 @@
   "source": {
     "spec": "frontend/openapi.json",
     "spec_version": "11.8.0",
-    "paths": 414,
-    "operations": 456,
+    "paths": 415,
+    "operations": 457,
     "classification": "scout_routes.md (v11.6.0 route inventory) + docs/v11.6.0_ONE_DOOR_PLAN.md",
     "module_attribution": "FastAPI route.endpoint.__module__ of the app built by scripts/export_openapi.py"
   },
@@ -82,7 +82,7 @@
       "wp": "R8",
       "target": "lattice-platform / lattice-agent",
       "summary": "MCP, marketplace, plugin SDK, agent registry, multi-agent runtime and the direct tool surface.",
-      "operations": 86
+      "operations": 87
     },
     "portability_network": {
       "wp": "R9",
@@ -1746,6 +1746,10 @@
       "module": "latticeai.api.marketplace",
       "family": "mcp_market"
     },
+    "POST /mcp": {
+      "module": "latticeai.api.mcp",
+      "family": "mcp_market"
+    },
     "POST /mcp/call": {
       "module": "latticeai.api.mcp",
       "family": "mcp_market"

package/scripts/publish_release.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+// One-command publish for a built release: npm, PyPI, VS Code Marketplace, OpenVSX.
+//
+//   node scripts/publish_release.mjs           # publish every target not yet at this version
+//   node scripts/publish_release.mjs --dry-run # report what would happen, publish nothing
+//
+// Run it from anywhere — the script cd's to the repo root itself. It publishes the
+// artifacts `npm run release:artifacts` already built and never rebuilds them.
+// Each registry is checked first, so re-running after a partial failure only
+// retries what is actually missing.
+//
+// Credentials (never passed as argv — argv leaks into shell history and npm logs):
+//   npm          — `npm login` session;每 publish마다 브라우저 2FA 승인이 뜬다.
+//   PyPI         — ~/.pypirc, TWINE_USERNAME/TWINE_PASSWORD, or interactive prompt.
+//   Marketplace  — VSCE_PAT environment variable.
+//   OpenVSX      — OVSX_PAT environment variable.
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+process.chdir(ROOT);
+
+const DRY = process.argv.includes("--dry-run");
+const pkg = JSON.parse(readFileSync(path.join(ROOT, "package.json"), "utf8"));
+const V = pkg.version;
+const PUBLISHER = JSON.parse(
+  readFileSync(path.join(ROOT, "vscode-extension", "package.json"), "utf8"),
+).publisher;
+
+const TGZ = path.join(ROOT, `ltcai-${V}.tgz`);
+const WHEEL = path.join(ROOT, "dist", `ltcai-${V}-py3-none-any.whl`);
+const SDIST = path.join(ROOT, "dist", `ltcai-${V}.tar.gz`);
+const VSIX = path.join(ROOT, "dist", `ltcai-${V}.vsix`);
+
+function run(cmd, args, env = {}) {
+  const r = spawnSync(cmd, args, {
+    stdio: "inherit",
+    cwd: ROOT,
+    env: { ...process.env, ...env },
+  });
+  return r.status === 0;
+}
+
+async function json(url, init) {
+  try {
+    const res = await fetch(url, init);
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+
+const checks = {
+  async npm() {
+    const d = await json(`https://registry.npmjs.org/ltcai/${V}`);
+    return d?.version === V;
+  },
+  async pypi() {
+    return (await json(`https://pypi.org/pypi/ltcai/${V}/json`)) !== null;
+  },
+  async marketplace() {
+    const d = await json(
+      "https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json;api-version=3.0-preview.1",
+        },
+        body: JSON.stringify({
+          filters: [{ criteria: [{ filterType: 7, value: `${PUBLISHER}.ltcai` }] }],
+          flags: 1,
+        }),
+      },
+    );
+    const ext = d?.results?.[0]?.extensions?.[0];
+    return ext?.versions?.some((x) => x.version === V) ?? false;
+  },
+  async openvsx() {
+    return (await json(`https://open-vsx.org/api/${PUBLISHER}/ltcai/${V}`)) !== null;
+  },
+};
+
+const targets = [
+  {
+    name: "npm",
+    artifacts: [TGZ],
+    credsMissing: () => null, // npm prompts its own browser 2FA
+    publish: () => run("npm", ["publish", TGZ]),
+    note: "브라우저 2FA 승인 창이 뜨면 승인해야 완료됩니다.",
+  },
+  {
+    name: "pypi",
+    artifacts: [SDIST, WHEEL],
+    credsMissing: () => null, // twine falls back to ~/.pypirc or an interactive prompt
+    publish: () =>
+      run("node", [
+        "scripts/run_python.mjs",
+        "-m",
+        "twine",
+        "upload",
+        "--skip-existing",
+        SDIST,
+        WHEEL,
+      ]),
+  },
+  {
+    name: "marketplace",
+    artifacts: [VSIX],
+    credsMissing: () => (process.env.VSCE_PAT ? null : "VSCE_PAT 환경변수가 필요합니다"),
+    publish: () => run("npx", ["--yes", "@vscode/vsce", "publish", "--packagePath", VSIX]),
+    note: "게시 후 마켓플레이스 검증에 몇 분 걸릴 수 있습니다.",
+  },
+  {
+    name: "openvsx",
+    artifacts: [VSIX],
+    credsMissing: () => (process.env.OVSX_PAT ? null : "OVSX_PAT 환경변수가 필요합니다"),
+    publish: () => run("npx", ["--yes", "ovsx", "publish", VSIX]),
+  },
+];
+
+const results = [];
+for (const t of targets) {
+  const already = await checks[t.name]();
+  if (already) {
+    results.push([t.name, "already-published"]);
+    continue;
+  }
+  const missing = t.artifacts.filter((a) => !existsSync(a));
+  if (missing.length) {
+    results.push([t.name, `artifact missing: ${missing.map((m) => path.basename(m)).join(", ")}`]);
+    continue;
+  }
+  const creds = t.credsMissing();
+  if (creds) {
+    results.push([t.name, `skipped: ${creds}`]);
+    continue;
+  }
+  if (DRY) {
+    results.push([t.name, "would publish"]);
+    continue;
+  }
+  if (t.note) console.log(`\n[${t.name}] ${t.note}`);
+  console.log(`[${t.name}] publishing v${V}…`);
+  results.push([t.name, t.publish() ? "published" : "FAILED"]);
+}
+
+console.log(`\n=== publish report — ltcai v${V} ===`);
+for (const [name, status] of results) console.log(`  ${name.padEnd(12)} ${status}`);
+
+const bad = results.filter(
+  ([, s]) => s === "FAILED" || s.startsWith("artifact missing") || s.startsWith("skipped"),
+);
+process.exit(bad.length ? 1 : 0);

package/scripts/release_screen_claims.json

@@ -20,6 +20,18 @@
     "whole-image delta: naming where the change is makes the claim more",
     "specific, not less."
   ],
+  "12.0.0": {
+    "_why": [
+      "Open House brings component and resilience updates across the frontend:",
+      "FolderMemoryHealth gained the 「삭제된 파일 정리 (N)」 button + preview dialog,",
+      "error boundaries added around views, preview pattern extended, and code",
+      "splitting (lazy view chunks).",
+      "",
+      "Brain/Chat home is unchanged since 11.8.0. Screens not touched are claimed",
+      "unchanged. The prune button renders conditionally and preview is user-triggered,",
+      "so static baseline captures remain unchanged. Empty claim set on purpose."
+    ]
+  },
   "11.9.0": {
     "_why": [
       "Working Order is a backend-truth release. The product work is live",