npm - ltcai - Versions diffs - 4.3.0 → 4.3.3 - Mend

ltcai 4.3.0 → 4.3.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

package/README.md +186 -276
package/bin/ltcai.js +6 -2
package/docs/CHANGELOG.md +124 -3
package/docs/V4_3_2_DEADCODE_AUDIT_REPORT.md +174 -0
package/docs/V4_3_2_DOCUMENTATION_CLEANUP_REPORT.md +81 -0
package/docs/V4_3_2_GITHUB_VERCEL_CHECK_REPORT.md +75 -0
package/docs/V4_3_2_GRAPH_UX_REPORT.md +48 -0
package/docs/V4_3_2_INDEPENDENT_AUDIT_PACKAGE.md +209 -0
package/docs/V4_3_2_PRODUCT_POLISH_REPORT.md +57 -0
package/docs/V4_3_2_SELF_AUDIT_REPORT.md +63 -0
package/docs/V4_3_2_VALIDATION_REPORT.md +97 -0
package/docs/V4_3_3_VALIDATION_REPORT.md +46 -0
package/docs/V4_DIGITAL_BRAIN_RECOVERY.md +18 -25
package/frontend/openapi.json +11 -1
package/frontend/src/App.tsx +15 -1
package/frontend/src/api/client.ts +19 -1
package/frontend/src/api/openapi.ts +10 -0
package/frontend/src/components/primitives.tsx +92 -10
package/frontend/src/pages/Act.tsx +72 -9
package/frontend/src/pages/Ask.tsx +2 -2
package/frontend/src/pages/Brain.tsx +607 -65
package/frontend/src/pages/Capture.tsx +11 -7
package/frontend/src/pages/Library.tsx +12 -6
package/frontend/src/pages/System.tsx +186 -23
package/lattice_brain/__init__.py +1 -1
package/lattice_brain/archive.py +3 -3
package/lattice_brain/storage/sqlite.py +15 -2
package/latticeai/__init__.py +1 -1
package/latticeai/api/agents.py +3 -1
package/latticeai/api/models.py +66 -18
package/latticeai/brain/projection.py +12 -2
package/latticeai/brain/retrieval.py +10 -0
package/latticeai/brain/store.py +6 -1
package/latticeai/core/config.py +3 -1
package/latticeai/core/marketplace.py +1 -1
package/latticeai/core/multi_agent.py +1 -1
package/latticeai/core/product_hardening.py +2 -1
package/latticeai/core/workspace_os.py +1 -1
package/latticeai/services/agent_runtime.py +52 -12
package/latticeai/services/model_runtime.py +83 -2
package/ltcai_cli.py +14 -3
package/package.json +5 -7
package/requirements.txt +17 -0
package/scripts/build_vercel_static.mjs +77 -0
package/scripts/check_markdown_links.mjs +75 -0
package/src-tauri/Cargo.lock +1 -1
package/src-tauri/Cargo.toml +1 -1
package/src-tauri/src/main.rs +269 -27
package/src-tauri/tauri.conf.json +20 -1
package/static/app/asset-manifest.json +5 -5
package/static/app/assets/index-CHHal8Zl.css +2 -0
package/static/app/assets/index-pdzil9ac.js +333 -0
package/static/app/assets/index-pdzil9ac.js.map +1 -0
package/static/app/index.html +2 -2
package/latticeai/api/deps.py +0 -15
package/scripts/capture/README.md +0 -28
package/scripts/capture/capture_enterprise.js +0 -8
package/scripts/capture/capture_graph.js +0 -8
package/scripts/capture/capture_onboarding.js +0 -8
package/scripts/capture/capture_page.js +0 -43
package/scripts/capture/capture_release_media.js +0 -125
package/scripts/capture/capture_skills.js +0 -8
package/scripts/capture/capture_v340.js +0 -88
package/scripts/capture/capture_workspace.js +0 -8
package/scripts/generate_diagrams.py +0 -512
package/scripts/release-0.3.1.sh +0 -105
package/scripts/take_screenshots.js +0 -69
package/static/app/assets/index-RiJTJliG.js +0 -333
package/static/app/assets/index-RiJTJliG.js.map +0 -1
package/static/app/assets/index-yZswHE3d.css +0 -2
package/static/css/tokens.3ba22e37.css +0 -260

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "ltcai",
-  "version": "4.3.0",
-  "description": "Lattice AI — local-first Digital Brain Platform (knowledge graph, durable memory, hybrid search, agents, signed brain exchange)",
+  "version": "4.3.3",
+  "description": "Lattice AI — local-first Digital Brain Platform (knowledge graph, durable memory, hybrid search, agents, portable encrypted brain archives)",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
     "type": "git",
@@ -25,17 +25,14 @@
     "check:python": "node scripts/run_python.mjs scripts/check_python.py",
     "lint": "node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend",
     "lint:frontend": "node scripts/lint_frontend.mjs",
+    "docs:check-links": "node scripts/check_markdown_links.mjs",
     "typecheck": "npm run typecheck:frontend && cd vscode-extension && npm run build",
     "typecheck:frontend": "npx tsc -p tsconfig.json --noEmit",
     "test": "node scripts/run_python.mjs -m pytest tests/ -v",
     "test:unit": "node scripts/run_python.mjs -m pytest tests/unit/ -v",
     "test:integration": "node scripts/run_python.mjs -m pytest tests/integration/ -v",
     "test:visual": "playwright test",
-    "capture:workspace": "node scripts/capture/capture_workspace.js",
-    "capture:graph": "node scripts/capture/capture_graph.js",
-    "capture:skills": "node scripts/capture/capture_skills.js",
-    "capture:enterprise": "node scripts/capture/capture_enterprise.js",
-    "capture:onboarding": "node scripts/capture/capture_onboarding.js",
+    "vercel:build": "node scripts/build_vercel_static.mjs",
     "desktop:tauri": "tauri dev",
     "desktop:tauri:build": "tauri build",
     "desktop:tauri:check": "cd src-tauri && cargo check",
@@ -68,6 +65,7 @@
   "files": [
     "bin/ltcai.js",
     "LICENSE",
+    "requirements.txt",
     "ltcai_cli.py",
     "auto_setup.py",
     "server.py",

package/requirements.txt ADDED Viewed

@@ -0,0 +1,17 @@
+fastapi>=0.110,<1
+uvicorn>=0.29,<1
+pydantic>=2.7,<3
+httpx>=0.27,<1
+pillow>=10,<13
+openai>=1.30,<3
+python-docx>=1.1,<2
+openpyxl>=3.1,<4
+python-pptx>=0.6.23,<2
+python-multipart>=0.0.9,<0.1
+keyring>=24,<26
+authlib>=1.3,<2
+cryptography>=42,<49
+pdfplumber>=0.11,<0.12
+pypdfium2>=4.30,<6
+watchdog>=4,<7
+psycopg[binary]>=3.2,<4

package/scripts/build_vercel_static.mjs ADDED Viewed

@@ -0,0 +1,77 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const outDir = new URL("../vercel-static/", import.meta.url);
+await mkdir(outDir, { recursive: true });
+const html = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Lattice AI ${pkg.version}</title>
+    <style>
+      :root {
+        color-scheme: dark;
+        font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        background: #0f141b;
+        color: #e5edf4;
+      }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        padding: 32px;
+      }
+      main {
+        max-width: 760px;
+        border: 1px solid #2d3745;
+        border-radius: 8px;
+        padding: 32px;
+        background: #151b24;
+      }
+      h1 {
+        margin: 0 0 12px;
+        font-size: 32px;
+      }
+      p {
+        line-height: 1.6;
+        color: #b8c4d2;
+      }
+      a {
+        color: #41ddd2;
+      }
+      code {
+        background: #0f141b;
+        border: 1px solid #2d3745;
+        border-radius: 4px;
+        padding: 2px 6px;
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Lattice AI ${pkg.version}</h1>
+      <p>
+        Lattice AI is a local-first desktop Digital Brain. The product runtime is the
+        Tauri desktop app plus a localhost FastAPI sidecar; it is not hosted on Vercel.
+      </p>
+      <p>
+        This Vercel build is intentionally documentation-only so Git integration checks
+        do not try to deploy the desktop runtime or a fake cloud app.
+      </p>
+      <p>
+        Use the validated desktop/package artifacts from the GitHub release process.
+        Repository: <a href="${pkg.homepage}">${pkg.homepage}</a>
+      </p>
+      <p>Runtime route when installed locally: <code>http://127.0.0.1:4825/app</code></p>
+    </main>
+  </body>
+</html>
+`;
+await writeFile(new URL("index.html", outDir), html, "utf8");
+console.log(`Vercel static placeholder generated for Lattice AI ${pkg.version}`);

package/scripts/check_markdown_links.mjs ADDED Viewed

@@ -0,0 +1,75 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+const root = process.cwd();
+const readme = path.join(root, "README.md");
+const checkedMarkdown = new Set();
+const failures = [];
+function stripAnchor(target) {
+  const hash = target.indexOf("#");
+  return hash >= 0 ? target.slice(0, hash) : target;
+}
+function isExternal(target) {
+  return /^(https?:|mailto:|tel:)/i.test(target);
+}
+function decodeTarget(target) {
+  return decodeURIComponent(target.replace(/^<|>$/g, ""));
+}
+function localPath(fromFile, target) {
+  const cleaned = stripAnchor(target).trim();
+  if (!cleaned || isExternal(cleaned)) return null;
+  return path.resolve(path.dirname(fromFile), decodeTarget(cleaned));
+}
+function links(markdown) {
+  const out = [];
+  const linkPattern = /!?\[[^\]]*\]\(([^)]+)\)/g;
+  let match;
+  while ((match = linkPattern.exec(markdown))) {
+    out.push(match[1].trim());
+  }
+  return out;
+}
+function checkFileLink(fromFile, target) {
+  const resolved = localPath(fromFile, target);
+  if (!resolved) return;
+  if (!resolved.startsWith(root)) {
+    failures.push(`${path.relative(root, fromFile)} links outside repo: ${target}`);
+    return;
+  }
+  if (!existsSync(resolved)) {
+    failures.push(`${path.relative(root, fromFile)} has missing link: ${target}`);
+  }
+}
+function checkMarkdownFile(file) {
+  if (checkedMarkdown.has(file)) return;
+  checkedMarkdown.add(file);
+  const markdown = readFileSync(file, "utf8");
+  for (const target of links(markdown)) {
+    checkFileLink(file, target);
+  }
+}
+checkMarkdownFile(readme);
+for (const target of links(readFileSync(readme, "utf8"))) {
+  const resolved = localPath(readme, target);
+  if (!resolved || !existsSync(resolved)) continue;
+  if (statSync(resolved).isFile() && resolved.endsWith(".md")) {
+    checkMarkdownFile(resolved);
+  }
+}
+if (failures.length) {
+  console.error("Markdown link check failed:");
+  for (const failure of failures) console.error(`- ${failure}`);
+  process.exit(1);
+}
+console.log(`Markdown link check passed for README and ${checkedMarkdown.size - 1} README-linked Markdown files.`);

package/src-tauri/Cargo.lock CHANGED Viewed

@@ -1654,7 +1654,7 @@ dependencies = [
 [[package]]
 name = "lattice-ai-desktop"
-version = "4.3.0"
+version = "4.3.3"
 dependencies = [
  "plist",
  "serde",

package/src-tauri/Cargo.toml CHANGED Viewed

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

package/src-tauri/src/main.rs CHANGED Viewed

@@ -1,5 +1,7 @@
 use std::{
     env,
+    fs::OpenOptions,
+    path::PathBuf,
     process::{Child, Command, Stdio},
     sync::Mutex,
 };
@@ -10,6 +12,7 @@ use tauri::{Manager, State};
 struct BackendState {
     origin: String,
     command: String,
+    cwd: Option<String>,
     child: Mutex<Option<Child>>,
     last_error: Mutex<Option<String>>,
 }
@@ -18,11 +21,19 @@ struct BackendState {
 struct BackendStatus {
     origin: String,
     command: String,
+    cwd: Option<String>,
     running: bool,
     pid: Option<u32>,
     last_error: Option<String>,
 }
+struct BackendLaunch {
+    command: String,
+    program: String,
+    args: Vec<String>,
+    cwd: Option<PathBuf>,
+}
 #[tauri::command]
 fn backend_origin(state: State<'_, BackendState>) -> String {
     state.origin.clone()
@@ -36,7 +47,8 @@ fn backend_status(state: State<'_, BackendState>) -> BackendStatus {
 #[tauri::command]
 fn restart_backend(state: State<'_, BackendState>) -> BackendStatus {
     kill_backend(&state);
-    match spawn_backend(&state.origin, &state.command) {
+    let launch = backend_launch(&state.origin);
+    match spawn_backend(&state.origin, &launch) {
         Ok(child) => {
             if let Ok(mut slot) = state.child.lock() {
                 *slot = child;
@@ -55,15 +67,174 @@ fn shutdown_backend(state: State<'_, BackendState>) -> BackendStatus {
 }
 fn split_command(command: &str) -> Vec<String> {
-    command
-        .split_whitespace()
-        .map(|part| part.to_string())
-        .collect()
+    command.split_whitespace().map(|part| part.to_string()).collect()
+}
+fn command_in_path(name: &str) -> Option<String> {
+    let mut dirs: Vec<PathBuf> = env::var_os("PATH")
+        .map(|value| env::split_paths(&value).collect())
+        .unwrap_or_default();
+    dirs.extend([
+        PathBuf::from("/opt/homebrew/bin"),
+        PathBuf::from("/usr/local/bin"),
+        PathBuf::from("/usr/bin"),
+        PathBuf::from("/bin"),
+    ]);
+    for dir in dirs {
+        let candidate = dir.join(name);
+        if candidate.is_file() {
+            return Some(candidate.to_string_lossy().to_string());
+        }
+    }
+    None
+}
+fn python_candidates() -> Vec<String> {
+    let mut out = Vec::new();
+    if let Ok(value) = env::var("LTCAI_PYTHON") {
+        out.push(value);
+    }
+    for name in ["python3", "python"] {
+        if let Some(path) = command_in_path(name) {
+            out.push(path);
+        }
+    }
+    out.extend([
+        "/opt/homebrew/bin/python3".to_string(),
+        "/usr/local/bin/python3".to_string(),
+        "/usr/bin/python3".to_string(),
+    ]);
+    out.sort();
+    out.dedup();
+    out
+}
+fn module_importable(python: &str, module: &str) -> bool {
+    Command::new(python)
+        .args(["-c", &format!("import {module}")])
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+        .map(|status| status.success())
+        .unwrap_or(false)
 }
-fn backend_command() -> String {
-    env::var("LATTICEAI_DESKTOP_BACKEND_CMD")
-        .unwrap_or_else(|_| "python3 ltcai_cli.py --host 127.0.0.1 --port 8765".to_string())
+fn resource_dir() -> Option<PathBuf> {
+    let exe = env::current_exe().ok()?;
+    let macos_dir = exe.parent()?;
+    let contents_dir = macos_dir.parent()?;
+    let resources = contents_dir.join("Resources");
+    if resources.exists() {
+        Some(resources)
+    } else {
+        None
+    }
+}
+fn bundled_python_root() -> Option<PathBuf> {
+    let resources = resource_dir()?;
+    let up = resources.join("_up_");
+    if up.join("ltcai_cli.py").is_file() {
+        Some(up)
+    } else if resources.join("ltcai_cli.py").is_file() {
+        Some(resources)
+    } else {
+        None
+    }
+}
+fn desktop_runtime_dir() -> Option<PathBuf> {
+    let home = env::var("HOME").ok()?;
+    let dir = PathBuf::from(home).join(".ltcai").join("desktop-runtime");
+    let _ = std::fs::create_dir_all(&dir);
+    Some(dir)
+}
+fn python_path_env(launch: &BackendLaunch) -> Option<String> {
+    let mut paths: Vec<PathBuf> = Vec::new();
+    if let Some(resources) = bundled_python_root() {
+        paths.push(resources);
+    }
+    if let Some(cwd) = &launch.cwd {
+        if !paths.iter().any(|path| path == cwd) {
+            paths.push(cwd.clone());
+        }
+    }
+    if let Some(existing) = env::var_os("PYTHONPATH") {
+        paths.extend(env::split_paths(&existing));
+    }
+    env::join_paths(paths).ok().map(|value| value.to_string_lossy().to_string())
+}
+fn backend_launch(origin: &str) -> BackendLaunch {
+    let port = origin.rsplit(':').next().unwrap_or("8765").to_string();
+    if let Ok(command) = env::var("LATTICEAI_DESKTOP_BACKEND_CMD") {
+        let parts = split_command(&command);
+        if let Some(program) = parts.first() {
+            return BackendLaunch {
+                command,
+                program: program.clone(),
+                args: parts[1..].to_vec(),
+                cwd: env::var("LATTICEAI_DESKTOP_BACKEND_CWD").ok().map(PathBuf::from),
+            };
+        }
+    }
+    for name in ["LTCAI", "ltcai"] {
+        if let Some(program) = command_in_path(name) {
+            return BackendLaunch {
+                command: format!("{program} --host 127.0.0.1 --port {port}"),
+                program,
+                args: vec!["--host".into(), "127.0.0.1".into(), "--port".into(), port],
+                cwd: None,
+            };
+        }
+    }
+    for python in python_candidates() {
+        if module_importable(&python, "ltcai_cli") {
+            return BackendLaunch {
+                command: format!("{python} -m ltcai_cli --host 127.0.0.1 --port {port}"),
+                program: python,
+                args: vec![
+                    "-m".into(),
+                    "ltcai_cli".into(),
+                    "--host".into(),
+                    "127.0.0.1".into(),
+                    "--port".into(),
+                    port,
+                ],
+                cwd: None,
+            };
+        }
+    }
+    if let Some(resources) = bundled_python_root() {
+        let launcher = resources.join("ltcai_cli.py");
+        if launcher.is_file() {
+            if let Some(python) = python_candidates().into_iter().next() {
+                return BackendLaunch {
+                    command: format!("{python} {} --host 127.0.0.1 --port {port}", launcher.display()),
+                    program: python,
+                    args: vec![
+                        launcher.to_string_lossy().to_string(),
+                        "--host".into(),
+                        "127.0.0.1".into(),
+                        "--port".into(),
+                        port,
+                    ],
+                    cwd: None,
+                };
+            }
+        }
+    }
+    BackendLaunch {
+        command: "unavailable: LTCAI executable or importable ltcai_cli module not found".to_string(),
+        program: String::new(),
+        args: Vec::new(),
+        cwd: None,
+    }
 }
 fn set_error(state: &BackendState, err: Option<String>) {
@@ -72,30 +243,64 @@ fn set_error(state: &BackendState, err: Option<String>) {
     }
 }
-fn spawn_backend(origin: &str, command: &str) -> Result<Option<Child>, String> {
+fn spawn_backend(origin: &str, launch: &BackendLaunch) -> Result<Option<Child>, String> {
     if env::var("LATTICEAI_DESKTOP_NO_BACKEND").is_ok() {
         return Ok(None);
     }
-    let parts = split_command(&command);
-    if parts.is_empty() {
-        return Err("Desktop backend command is empty.".to_string());
+    if launch.program.is_empty() {
+        return Err("Desktop backend unavailable: LTCAI executable or importable ltcai_cli module not found.".to_string());
     }
-    let mut cmd = Command::new(&parts[0]);
-    cmd.args(&parts[1..])
+    let mut cmd = Command::new(&launch.program);
+    cmd.args(&launch.args)
         .env("LATTICEAI_HOST", "127.0.0.1")
         .env("LATTICEAI_PORT", origin.rsplit(':').next().unwrap_or("8765"))
         .env("LATTICEAI_ENABLE_TELEGRAM", "false")
         .env("LATTICEAI_AUTOLOAD_MODELS", "false")
+        .env("LATTICEAI_ALLOW_MODEL_DOWNLOADS", "false")
         .env("LATTICEAI_CORS_ALLOW_NETWORK", "false")
+        .env("LATTICEAI_ENABLE_EXTERNAL_CONNECTORS", "false")
         .env("LATTICEAI_TUNNEL", "false")
-        .stdout(Stdio::null())
-        .stderr(Stdio::null());
-    if let Ok(cwd) = env::var("LATTICEAI_DESKTOP_BACKEND_CWD") {
+        .env(
+            "PATH",
+            format!(
+                "{}:{}",
+                "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin",
+                env::var("PATH").unwrap_or_default()
+            ),
+        );
+    if let Some(runtime_dir) = desktop_runtime_dir() {
+        cmd.env("LATTICEAI_AGENT_ROOT", runtime_dir.join("agent_workspace"));
+        if launch.cwd.is_none() {
+            cmd.current_dir(&runtime_dir);
+        }
+    }
+    if let Some(python_path) = python_path_env(launch) {
+        cmd.env("PYTHONPATH", python_path);
+    }
+    if let Some(cwd) = &launch.cwd {
         cmd.current_dir(cwd);
     }
+    if let Ok(home) = env::var("HOME") {
+        let log_dir = PathBuf::from(home).join(".ltcai");
+        let _ = std::fs::create_dir_all(&log_dir);
+        if let Ok(file) = OpenOptions::new().create(true).append(true).open(log_dir.join("desktop-sidecar.log")) {
+            cmd.stdout(Stdio::from(file));
+        } else {
+            cmd.stdout(Stdio::null());
+        }
+        if let Ok(file) = OpenOptions::new().create(true).append(true).open(log_dir.join("desktop-sidecar.err.log")) {
+            cmd.stderr(Stdio::from(file));
+        } else {
+            cmd.stderr(Stdio::null());
+        }
+    } else {
+        cmd.stdout(Stdio::null()).stderr(Stdio::null());
+    }
     cmd.spawn()
         .map(Some)
-        .map_err(|err| format!("Failed to start desktop backend '{}': {}", parts[0], err))
+        .map_err(|err| format!("Failed to start desktop backend '{}': {}", launch.command, err))
 }
 fn kill_backend(state: &BackendState) {
@@ -125,25 +330,40 @@ fn status_from_state(state: &BackendState) -> BackendStatus {
             }
         }
     }
-    let last_error = state
-        .last_error
-        .lock()
-        .ok()
-        .and_then(|guard| guard.clone());
+    let last_error = state.last_error.lock().ok().and_then(|guard| guard.clone());
     BackendStatus {
         origin: state.origin.clone(),
         command: state.command.clone(),
+        cwd: state.cwd.clone(),
         running,
         pid,
         last_error,
     }
 }
+fn wait_for_backend(origin: &str) {
+    let host_port = origin
+        .trim_start_matches("http://")
+        .trim_start_matches("https://")
+        .split('/')
+        .next()
+        .unwrap_or("127.0.0.1:8765")
+        .to_string();
+    for _ in 0..45 {
+        if std::net::TcpStream::connect(&host_port).is_ok() {
+            return;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(500));
+    }
+}
 fn main() {
     let origin = env::var("LATTICEAI_DESKTOP_BACKEND_ORIGIN")
         .unwrap_or_else(|_| "http://127.0.0.1:8765".to_string());
-    let command = backend_command();
-    let (child, last_error) = match spawn_backend(&origin, &command) {
+    let launch = backend_launch(&origin);
+    let command = launch.command.clone();
+    let cwd = launch.cwd.as_ref().map(|path| path.to_string_lossy().to_string());
+    let (child, last_error) = match spawn_backend(&origin, &launch) {
         Ok(child) => (child, None),
         Err(err) => (None, Some(err)),
     };
@@ -151,6 +371,7 @@ fn main() {
         .manage(BackendState {
             origin,
             command,
+            cwd,
             child: Mutex::new(child),
             last_error: Mutex::new(last_error),
         })
@@ -163,6 +384,17 @@ fn main() {
         .setup(|app| {
             if let Some(window) = app.get_webview_window("main") {
                 let _ = window.set_title("Lattice AI");
+                let _ = window.show();
+                let _ = window.set_focus();
+                let origin = app.state::<BackendState>().origin.clone();
+                let target = format!("{}/app", origin.trim_end_matches('/'));
+                let mut window_for_nav = window.clone();
+                std::thread::spawn(move || {
+                    wait_for_backend(&origin);
+                    if let Ok(url) = tauri::Url::parse(&target) {
+                        let _ = window_for_nav.navigate(url);
+                    }
+                });
             }
             Ok(())
         })
@@ -173,6 +405,16 @@ fn main() {
                 }
             }
         })
-        .run(tauri::generate_context!())
-        .expect("failed to run Lattice AI desktop shell");
+        .build(tauri::generate_context!())
+        .expect("failed to build Lattice AI desktop shell")
+        .run(|app_handle, event| {
+            if matches!(
+                event,
+                tauri::RunEvent::ExitRequested { .. } | tauri::RunEvent::Exit
+            ) {
+                if let Some(state) = app_handle.try_state::<BackendState>() {
+                    kill_backend(&state);
+                }
+            }
+        });
 }

package/src-tauri/tauri.conf.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "Lattice AI",
-  "version": "4.3.0",
+  "version": "4.3.3",
   "identifier": "ai.lattice.desktop",
   "build": {
     "beforeDevCommand": "npm run frontend:dev",
@@ -31,6 +31,25 @@
       "dmg",
       "app"
     ],
+    "resources": [
+      "../auto_setup.py",
+      "../kg_schema.py",
+      "../knowledge_graph.py",
+      "../knowledge_graph_api.py",
+      "../llm_router.py",
+      "../local_knowledge_api.py",
+      "../ltcai_cli.py",
+      "../mcp_registry.py",
+      "../p_reinforce.py",
+      "../server.py",
+      "../setup_wizard.py",
+      "../telegram_bot.py",
+      "../requirements.txt",
+      "../latticeai",
+      "../lattice_brain",
+      "../tools",
+      "../static"
+    ],
     "icon": [
       "../static/icons/icon-192.png",
       "../static/icons/icon-512.png"

package/static/app/asset-manifest.json CHANGED Viewed

@@ -1,13 +1,13 @@
 {
-  "version": "4.3.0",
+  "version": "4.3.3",
   "generated_at": "vite",
   "entrypoints": {
     "app": "/static/app/index.html"
   },
   "assets": {
     "../node_modules/@tauri-apps/api/core.js": "/static/app/assets/core-CwxXejkd.js",
-    "index.html": "/static/app/assets/index-RiJTJliG.js",
-    "assets/index-yZswHE3d.css": "/static/app/assets/index-yZswHE3d.css"
+    "index.html": "/static/app/assets/index-pdzil9ac.js",
+    "assets/index-CHHal8Zl.css": "/static/app/assets/index-CHHal8Zl.css"
   },
   "vite": {
     "../node_modules/@tauri-apps/api/core.js": {
@@ -17,7 +17,7 @@
       "isDynamicEntry": true
     },
     "index.html": {
-      "file": "assets/index-RiJTJliG.js",
+      "file": "assets/index-pdzil9ac.js",
       "name": "index",
       "src": "index.html",
       "isEntry": true,
@@ -25,7 +25,7 @@
         "../node_modules/@tauri-apps/api/core.js"
       ],
       "css": [
-        "assets/index-yZswHE3d.css"
+        "assets/index-CHHal8Zl.css"
       ]
     }
   }