ltcai 7.5.0 → 7.7.0

package/latticeai/services/model_runtime.py

@@ -32,6 +32,7 @@ from latticeai.models.router import (
     HF_MODELS_ROOT,
     OPENAI_COMPATIBLE_PROVIDERS,
     ensure_mlx_runtime,
+    hf_cache_model_dir,
     hf_model_dir,
     parse_model_ref,
 )
@@ -429,10 +430,12 @@ def engine_support_status(engine: str) -> Dict[str, object]:
 
 def hf_model_ready(repo_id: str, provider: str = "local_mlx") -> bool:
     model_dir = hf_model_dir(repo_id)
-    if provider == "vllm" and (not model_dir.exists() or not model_dir.is_dir()):
+    if provider in {"local_mlx", "vllm"} and (not model_dir.exists() or not model_dir.is_dir()):
         hf_cache_repo = Path.home() / ".cache" / "huggingface" / "hub" / f"models--{repo_id.replace('/', '--')}"
         if hf_cache_repo.exists() and any(hf_cache_repo.glob("snapshots/*")):
-            return True
+            if provider == "vllm":
+                return True
+            return hf_cache_model_dir(repo_id) is not None
         return False
     if not model_dir.exists() or not model_dir.is_dir():
         return False
@@ -520,6 +523,8 @@ def download_hf_model(
 
     target_dir = hf_model_dir(repo_id)
     if hf_model_ready(repo_id, provider):
+        cached_dir = hf_cache_model_dir(repo_id) if provider == "local_mlx" else None
+        resolved_dir = cached_dir or target_dir
         if progress_emit:
             progress_emit(model_download_progress_payload(
                 "download",
@@ -529,7 +534,7 @@ def download_hf_model(
                 total_bytes=0,
                 eta_seconds=0,
             ))
-        return {"model": repo_id, "path": str(target_dir), "cached": True}
+        return {"model": repo_id, "path": str(resolved_dir), "cached": True}
 
     target_dir.mkdir(parents=True, exist_ok=True)
     try:

package/latticeai/services/product_readiness.py

@@ -0,0 +1,159 @@
+"""Machine-checkable *product* readiness gates for the 7.7 line.
+
+Where ``architecture_readiness`` proves the internal structure is sound, this
+module answers the product question the 7.7 release exists to settle: *would
+anyone looking at this call it a finished product?* It does so honestly — every
+gate is backed by evidence that is probed on disk, so a gate only reports
+``complete`` when its evidence actually resolves. The same report can be printed
+by ``scripts/product_readiness.py`` and re-run after every change, which is the
+point: completeness is something we keep measuring, not a one-time claim.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List
+
+from latticeai.services.architecture_readiness import architecture_readiness
+
+PRODUCT_VERSION_TARGET = "7.7.0"
+
+
+@dataclass(frozen=True)
+class ProductGate:
+    id: str
+    title: str
+    # Evidence is either a repo-relative path that must exist, or
+    # "path::needle" meaning the file must exist and contain ``needle``.
+    evidence: List[str]
+
+
+PRODUCT_GATES: List[ProductGate] = [
+    ProductGate(
+        id="first-run",
+        title="First five minutes lands without a manual",
+        evidence=[
+            "frontend/src/components/ProductFlow.tsx::WakeBrainScreen",
+            "frontend/src/features/brain/BrainConversation.tsx::ProductCommandCenter",
+            "frontend/src/features/brain/BrainHome.tsx",
+            "auto_setup.py",
+            "setup_wizard.py",
+        ],
+    ),
+    ProductGate(
+        id="answer-proof",
+        title="Answers carry memory proof and citations",
+        evidence=[
+            "latticeai/api/memory.py::brain-proof",
+            "scripts/brain_quality_eval.py",
+        ],
+    ),
+    ProductGate(
+        id="local-first-trust",
+        title="Local-first privacy is stated and bounded",
+        evidence=[
+            "PRIVACY.md",
+            "PUBLIC_MODE.md",
+            "SECURITY.md",
+        ],
+    ),
+    ProductGate(
+        id="packaging",
+        title="One command produces shippable artifacts",
+        evidence=[
+            "package.json::release:artifacts",
+            "package.json::release:validate",
+            "README.md::dist/ltcai-7.7.0-py3-none-any.whl",
+            "README.md::dist/ltcai-7.7.0.tar.gz",
+            "README.md::dist/ltcai-7.7.0.vsix",
+            "README.md::ltcai-7.7.0.tgz",
+            "scripts/validate_release_artifacts.py",
+            "scripts/release_smoke.py",
+            "Dockerfile",
+        ],
+    ),
+    ProductGate(
+        id="architecture-closed",
+        title="Architecture readiness is complete",
+        evidence=["latticeai/services/architecture_readiness.py"],
+    ),
+    ProductGate(
+        id="trust-docs",
+        title="Release story is documented and honest",
+        evidence=[
+            "README.md",
+            "README.md::The current release is **7.7.0",
+            "SECURITY.md::7.7.x (latest)",
+            "vscode-extension/README.md::**7.7.0",
+            "docs/CHANGELOG.md::## [7.7.0]",
+            "FEATURE_STATUS.md",
+            "RELEASE_NOTES_v7.7.0.md",
+        ],
+    ),
+    ProductGate(
+        id="quality-gates",
+        title="Quality is guarded by repeatable gates",
+        evidence=[
+            "scripts/brain_quality_eval.py",
+            "scripts/product_readiness.py",
+            "tests/unit/test_v77_product_readiness.py",
+            "tests/visual/v3.spec.js::제품 상태판",
+            ".github/workflows/ci.yml::scripts/product_readiness.py",
+            ".github/workflows/release.yml::npm run lint",
+        ],
+    ),
+]
+
+
+def _evidence_resolves(root: Path, evidence: str) -> bool:
+    if "::" in evidence:
+        rel, needle = evidence.split("::", 1)
+        target = root / rel
+        if not target.is_file():
+            return False
+        try:
+            return needle in target.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            return False
+    return (root / evidence).exists()
+
+
+def product_readiness(root: Path | None = None) -> Dict[str, Any]:
+    if root is None:
+        root = Path(__file__).resolve().parents[2]
+
+    arch = architecture_readiness(root)
+
+    gate_reports: List[Dict[str, Any]] = []
+    for gate in PRODUCT_GATES:
+        missing = [e for e in gate.evidence if not _evidence_resolves(root, e)]
+        # The architecture gate is satisfied by the composed report, not just
+        # the file existing — fold its status in so this score can never claim
+        # product completeness while the structure underneath is incomplete.
+        if gate.id == "architecture-closed" and arch.get("status") != "complete":
+            missing = missing or ["architecture_readiness().status != complete"]
+        gate_reports.append(
+            {
+                "id": gate.id,
+                "title": gate.title,
+                "status": "complete" if not missing else "incomplete",
+                "evidence": gate.evidence,
+                "missing": missing,
+            }
+        )
+
+    complete = sum(1 for g in gate_reports if g["status"] == "complete")
+    total = len(gate_reports)
+    return {
+        "status": "complete" if complete == total else "incomplete",
+        "version_target": PRODUCT_VERSION_TARGET,
+        "score": f"{complete}/{total}",
+        "gates": gate_reports,
+        "architecture": arch["status"],
+        "metrics": {
+            "product_gates": total,
+            "product_gates_complete": complete,
+            **arch.get("metrics", {}),
+        },
+    }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "7.5.0",
+  "version": "7.7.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": {

package/scripts/product_readiness.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Print the 7.7 product-readiness scorecard and fail CI when incomplete.
+
+Run it as often as you like — it re-probes the repo every time, so it is the
+single objective answer to "is this a finished product yet?". Exit code is 0
+only when every product gate resolves its evidence on disk.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from latticeai.services.product_readiness import product_readiness  # noqa: E402
+
+
+def main() -> int:
+    report = product_readiness(REPO_ROOT)
+    print(f"Lattice AI product readiness — target {report['version_target']}")
+    print(f"Score: {report['score']}  (architecture: {report['architecture']})")
+    print("-" * 60)
+    for gate in report["gates"]:
+        mark = "✓" if gate["status"] == "complete" else "✗"
+        print(f"{mark} {gate['id']:<22} {gate['title']}")
+        for miss in gate["missing"]:
+            print(f"    missing: {miss}")
+    print("-" * 60)
+    print(f"STATUS: {report['status'].upper()}")
+    return 0 if report["status"] == "complete" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/pts-claudecode-discord-bridge.mjs

@@ -44,6 +44,18 @@ function stripAnsi(text) {
   return String(text || "").replace(/\u001b\[[0-9;]*m/g, "").trim();
 }
 
+function formatClaudeError(error) {
+  const message = stripAnsi(error?.message || error);
+  if (/401|Invalid authentication credentials|Failed to authenticate/i.test(message)) {
+    return [
+      "Claude Code 인증이 끊겼습니다.",
+      "로컬에서 `claude`를 열어 다시 로그인한 뒤 `pts_claudecode` 브리지를 재시작해야 합니다.",
+      "Discord 토큰 문제는 아니고, `/opt/homebrew/bin/claude -p` 호출이 401로 실패하고 있습니다.",
+    ].join(" ");
+  }
+  return `pts_claudecode 브리지 오류: ${message.slice(0, 800)}`;
+}
+
 function isAllowed(message, botId) {
   if (message.author.id === botId) return false;
   if (message.channelId !== channelId) return false;
@@ -117,8 +129,14 @@ function runClaudePrompt(prompt) {
 
     let stdout = "";
     let stderr = "";
+    let closed = false;
     const timer = setTimeout(() => {
       child.kill("SIGTERM");
+      setTimeout(() => {
+        if (!closed) {
+          child.kill("SIGKILL");
+        }
+      }, 5000).unref();
     }, runTimeoutMs);
 
     child.stdout.on("data", (chunk) => {
@@ -132,6 +150,7 @@ function runClaudePrompt(prompt) {
       reject(error);
     });
     child.on("close", (code, signal) => {
+      closed = true;
       clearTimeout(timer);
       if ((code !== 0 || signal) && !stdout.trim()) {
         reject(new Error(stripAnsi(stderr) || `claude exited with ${code || signal}`));
@@ -178,9 +197,7 @@ client.on("messageCreate", async (message) => {
       : reply;
     await message.reply(cleanReply || "pts_claudecode 응답 생성에 실패했습니다.");
   } catch (error) {
-    await message.reply(
-      `pts_claudecode 브리지 오류: ${String(error.message || error).slice(0, 800)}`,
-    );
+    await message.reply(formatClaudeError(error));
   } finally {
     busy = false;
   }

package/src-tauri/Cargo.lock

@@ -1584,7 +1584,7 @@ dependencies = [
 
 [[package]]
 name = "lattice-ai-desktop"
-version = "7.5.0"
+version = "7.7.0"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lattice-ai-desktop"
-version = "7.5.0"
+version = "7.7.0"
 description = "Lattice AI Digital Brain desktop shell"
 authors = ["TaeSoo Park"]
 edition = "2021"

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "7.5.0",
+  "version": "7.7.0",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",

package/static/app/asset-manifest.json

@@ -1,20 +1,20 @@
 {
-  "version": "7.5.0",
+  "version": "7.7.0",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "_primitives-CdwcE--L.js": "/static/app/assets/primitives-CdwcE--L.js",
-    "_textarea-CqOdBPL1.js": "/static/app/assets/textarea-CqOdBPL1.js",
-    "index.html": "/static/app/assets/index-COuGp7_5.js",
-    "assets/index-Bi_bpigM.css": "/static/app/assets/index-Bi_bpigM.css",
-    "src/pages/Act.tsx": "/static/app/assets/Act-Di4tRFWY.js",
-    "src/pages/Brain.tsx": "/static/app/assets/Brain-BZB3Gy9w.js",
-    "src/pages/Capture.tsx": "/static/app/assets/Capture-tNyYWxnh.js",
-    "src/pages/Library.tsx": "/static/app/assets/Library-DAtDDLdg.js",
-    "src/pages/System.tsx": "/static/app/assets/System-DEu0xNUc.js"
+    "_primitives-CFhU5Rka.js": "/static/app/assets/primitives-CFhU5Rka.js",
+    "_textarea-uBpGDOJM.js": "/static/app/assets/textarea-uBpGDOJM.js",
+    "index.html": "/static/app/assets/index-B4_drWel.js",
+    "assets/index-DjpDeE0c.css": "/static/app/assets/index-DjpDeE0c.css",
+    "src/pages/Act.tsx": "/static/app/assets/Act-CX5hL0Z3.js",
+    "src/pages/Brain.tsx": "/static/app/assets/Brain-m19en5wz.js",
+    "src/pages/Capture.tsx": "/static/app/assets/Capture-CdFSrZnA.js",
+    "src/pages/Library.tsx": "/static/app/assets/Library-CZFVGSmG.js",
+    "src/pages/System.tsx": "/static/app/assets/System-CMoOoUrZ.js"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -23,22 +23,22 @@
       "src": "../node_modules/@tauri-apps/api/core.js",
       "isDynamicEntry": true
     },
-    "_primitives-CdwcE--L.js": {
-      "file": "assets/primitives-CdwcE--L.js",
+    "_primitives-CFhU5Rka.js": {
+      "file": "assets/primitives-CFhU5Rka.js",
       "name": "primitives",
       "imports": [
         "index.html"
       ]
     },
-    "_textarea-CqOdBPL1.js": {
-      "file": "assets/textarea-CqOdBPL1.js",
+    "_textarea-uBpGDOJM.js": {
+      "file": "assets/textarea-uBpGDOJM.js",
       "name": "textarea",
       "imports": [
         "index.html"
       ]
     },
     "index.html": {
-      "file": "assets/index-COuGp7_5.js",
+      "file": "assets/index-B4_drWel.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -51,59 +51,59 @@
         "src/pages/System.tsx"
       ],
       "css": [
-        "assets/index-Bi_bpigM.css"
+        "assets/index-DjpDeE0c.css"
       ]
     },
     "src/pages/Act.tsx": {
-      "file": "assets/Act-Di4tRFWY.js",
+      "file": "assets/Act-CX5hL0Z3.js",
       "name": "Act",
       "src": "src/pages/Act.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-CdwcE--L.js",
-        "_textarea-CqOdBPL1.js"
+        "_primitives-CFhU5Rka.js",
+        "_textarea-uBpGDOJM.js"
       ]
     },
     "src/pages/Brain.tsx": {
-      "file": "assets/Brain-BZB3Gy9w.js",
+      "file": "assets/Brain-m19en5wz.js",
       "name": "Brain",
       "src": "src/pages/Brain.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-CdwcE--L.js",
-        "_textarea-CqOdBPL1.js"
+        "_primitives-CFhU5Rka.js",
+        "_textarea-uBpGDOJM.js"
       ]
     },
     "src/pages/Capture.tsx": {
-      "file": "assets/Capture-tNyYWxnh.js",
+      "file": "assets/Capture-CdFSrZnA.js",
       "name": "Capture",
       "src": "src/pages/Capture.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-CdwcE--L.js"
+        "_primitives-CFhU5Rka.js"
       ]
     },
     "src/pages/Library.tsx": {
-      "file": "assets/Library-DAtDDLdg.js",
+      "file": "assets/Library-CZFVGSmG.js",
       "name": "Library",
       "src": "src/pages/Library.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-CdwcE--L.js"
+        "_primitives-CFhU5Rka.js"
       ]
     },
     "src/pages/System.tsx": {
-      "file": "assets/System-DEu0xNUc.js",
+      "file": "assets/System-CMoOoUrZ.js",
       "name": "System",
       "src": "src/pages/System.tsx",
       "isDynamicEntry": true,
       "imports": [
         "index.html",
-        "_primitives-CdwcE--L.js"
+        "_primitives-CFhU5Rka.js"
       ]
     }
   }