ltcai 6.2.0 → 6.3.1

package/README.md

@@ -69,42 +69,42 @@ You need Lattice AI when:
 Choose the owner of the Brain. The profile is not a SaaS account by default; it
 is the local identity for the knowledge you keep.
 
-![Login](output/release/v6.2.0/screenshots/01-login.png)
+![Login](output/release/v6.3.1/screenshots/01-login.png)
 
 ### 2. Environment Analysis
 
 See what kind of local AI experience this computer can support before choosing a
 model.
 
-![Environment Analysis](output/release/v6.2.0/screenshots/02-environment-analysis.png)
+![Environment Analysis](output/release/v6.3.1/screenshots/02-environment-analysis.png)
 
 ### 3. Recommended Models
 
 Start with a short list: safest recommendation, faster model, stronger model.
 Advanced details stay available without overwhelming first-time users.
 
-![Recommended Models](output/release/v6.2.0/screenshots/03-recommended-models.png)
+![Recommended Models](output/release/v6.3.1/screenshots/03-recommended-models.png)
 
 ### 4. Install And Load
 
 Download and load only after consent. Lattice explains model size, local
 execution, and network use before work starts.
 
-![Install and Load](output/release/v6.2.0/screenshots/04-install-load-progress.png)
+![Install and Load](output/release/v6.3.1/screenshots/04-install-load-progress.png)
 
 ### 5. Brain Chat
 
 Talk normally. Useful decisions and context become memory, then appear later as
 topics, relationships, and graph structure.
 
-![Brain Chat Home](output/release/v6.2.0/screenshots/05-brain-chat-home.png)
+![Brain Chat Home](output/release/v6.3.1/screenshots/05-brain-chat-home.png)
 
 ### 6. Review Center
 
 Automation results are staged for review before they become durable decisions.
 Snooze, unsnooze, run now, approve, and dismiss actions stay explicit.
 
-![Review Center](output/release/v6.2.0/screenshots/13-review-center.png)
+![Review Center](output/release/v6.3.1/screenshots/13-review-center.png)
 
 ## Brain Depths
 
@@ -120,10 +120,10 @@ The user travels inward from everyday memory to deeper structure:
 
 Walkthrough:
 
-![v6.2.0 Living Brain walkthrough](output/release/v6.2.0/gifs/v6.2.0-living-brain-walkthrough.gif)
+![v6.3.1 Living Brain walkthrough](output/release/v6.3.1/gifs/v6.3.1-living-brain-walkthrough.gif)
 
 Screenshot index and capture notes:
-[output/release/v6.2.0/SCREENSHOT_INDEX.md](output/release/v6.2.0/SCREENSHOT_INDEX.md)
+[output/release/v6.3.1/SCREENSHOT_INDEX.md](output/release/v6.3.1/SCREENSHOT_INDEX.md)
 
 ## Install
 
@@ -200,7 +200,7 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for developer workflow details.
 
 ## Current Release Preparation
 
-The current development target is **6.2.0 Product Decomposition / Release Smoke Automation**:
+The current development target is **6.3.1 Access Runtime / i18n Follow-up**:
 
 - `App.tsx` now delegates the main Brain and Admin surfaces to focused feature
   modules instead of owning the full product shell.
@@ -217,14 +217,22 @@ The current development target is **6.2.0 Product Decomposition / Release Smoke
   app-factory parameter sprawl while preserving route order.
 - Release smoke automation now checks wheel install, npm tgz contents, static
   assets, and Tauri artifacts after exact-version artifact validation.
-
-Expected artifacts for 6.2.0 release must use exact filenames:
-
-- `dist/ltcai-6.2.0-py3-none-any.whl`
-- `dist/ltcai-6.2.0.tar.gz`
-- `ltcai-6.2.0.tgz`
-- `dist/ltcai-6.2.0.vsix`
-- `src-tauri/target/release/bundle/dmg/Lattice AI_6.2.0_aarch64.dmg`
+- Brain archive, memory provenance, document ingestion, Review Center Run Now,
+  local model runtime, root-shim smoke, and app-factory review wiring now have
+  dedicated UX/backend hardening coverage for the 6.3 line.
+- Access-control helper closures are extracted from `app_factory.py` into a
+  focused runtime module with direct unit coverage for role lookup, token
+  extraction, user enforcement, admin enforcement, and public user projection.
+- Capture and Review Center copy now route through the shared Korean/English
+  i18n map for tabs, placeholders, action labels, empty states, and feedback.
+
+Expected artifacts for 6.3.1 release must use exact filenames:
+
+- `dist/ltcai-6.3.1-py3-none-any.whl`
+- `dist/ltcai-6.3.1.tar.gz`
+- `ltcai-6.3.1.tgz`
+- `dist/ltcai-6.3.1.vsix`
+- `src-tauri/target/release/bundle/dmg/Lattice AI_6.3.1_aarch64.dmg`
 
 Do not upload `dist/*`. Package registry publishing remains owner-run.
 
@@ -243,6 +251,10 @@ Do not upload `dist/*`. Package registry publishing remains owner-run.
 
 | Version | Theme |
 | --- | --- |
+| 6.3.1 | Access Runtime / i18n Follow-up: app-factory access-control extraction, focused access runtime tests, and Capture/Review Center i18n coverage |
+| 6.3.0 | Product Hardening Completion: Brain archive/provenance/ingestion UX polish, Review Center Run Now contract hardening, local model runtime status, app-factory review wiring, shim smoke, i18n guard, and exact release artifacts |
+| 6.2.0 | Product Decomposition / Release Smoke Automation: App and ProductFlow feature extraction, legacy root shim shrink, model download consent UX, typed router contexts, localized smoke tests, and wheel/npm/static/Tauri release smoke |
+| 6.1.0 | Product Hardening / Digital Brain Completion: local Brain entry without a loaded model, Brain memory/backup loop, Review Center semantics, ToolRegistry authorization boundary, and root CLI/runtime compatibility |
 | 6.0.0 | Product Reset / Review Center Completion: Snoozed filter, Unsnooze, OpenAPI-derived Review typing, Review feature extraction, v6 docs and scorecard |
 | 5.6.0 | Brain Automation Review Center: workspace-scoped automation review inbox, source-aware provenance, guarded approve/dismiss/snooze/run_now actions, and Act Review tab |
 | 5.5.0 | Release Coordination: synchronized package/runtime/static versions and release docs for the 5.5.0 line while preserving v5.4.0 Brain Automation Scheduler behavior |

package/docs/CHANGELOG.md

@@ -3,6 +3,72 @@
 The top entry is the current release-preparation target. Older entries are
 historical and may describe behavior as it existed at that release.
 
+## [6.3.1] - 2026-06-17
+
+> Access Runtime / i18n Follow-up. Closes the next app-factory decomposition
+> slice and finishes Capture/Review Center localization coverage on top of the
+> v6.3.0 product-hardening line.
+
+### Changed
+- Moved app-factory access-control helper closures into
+  `latticeai.runtime.access_runtime` while preserving role lookup, token
+  extraction, user enforcement, admin enforcement, and public user projection
+  call signatures.
+- Capture tabs, headings, placeholders, action labels, upload details, folder
+  connection copy, browser capture copy, and pipeline controls now use the
+  shared Korean/English i18n map.
+- Review Center inbox/card copy, status badges, empty states, Run Now feedback,
+  snooze/unsnooze labels, and action aria labels now use the shared i18n map.
+- README release evidence screenshots and walkthrough GIF are refreshed under
+  `output/release/v6.3.1/`.
+- Package/runtime/static metadata is synchronized to 6.3.1; package publish and
+  deployment remain owner-run only.
+
+### Added
+- Focused unit coverage for the extracted access runtime auth/admin behavior.
+
+## [6.3.0] - 2026-06-16
+
+> Product Hardening Completion. Completes the 6.2 decomposition follow-up by
+> tightening Brain archive, provenance, ingestion, Review Center, local model
+> runtime, app-factory wiring, compatibility shim, i18n, and release-validation
+> surfaces.
+
+### Changed
+- Brain Home and onboarding screens are split into finer feature-owned modules
+  while preserving the existing routes, CSS surface, and visual behavior.
+- Platform and automation runtime wiring moved behind a dedicated app-factory
+  seam, keeping construction side-effect free and route order unchanged.
+- Admin, Brain, and onboarding localized aria/placeholder surfaces now use the
+  shared i18n map.
+- Brain archive care now validates archive paths, confirms passphrases, gives
+  strength guidance, and summarizes inspect/restore-preview results without
+  dumping raw JSON.
+- Document capture now exposes a drop/choose ingest queue with progress,
+  failure reason, retry, source metadata, and post-ingest Brain/Graph
+  confirmation.
+- Brain memory and graph surfaces now show provenance/source type, created time,
+  source path/title/conversation fallback, and copy-source affordances.
+- Review Center cards now keep visible action result/error feedback for
+  run-now/approve/dismiss/snooze flows while preserving run-now as
+  preview/regenerate rather than approval.
+- Local model setup now reports loaded model, engine state, cache/storage path,
+  download/load progress, reload/unload controls, and an honest no-model state.
+- App factory model/chat/review-tail wiring moved into focused runtime wiring
+  modules while preserving route order.
+- Review Center run-now backend wiring moved into `latticeai.runtime.review_wiring`
+  and is covered by scoped runner/status-preservation tests.
+- Legacy root shim import smoke now covers server, knowledge graph, CLI,
+  Telegram, and P-Reinforce compatibility paths.
+- Package/runtime/static metadata is synchronized to 6.3.0; package publish and
+  deployment remain owner-run only.
+
+### Added
+- Frontend i18n literal check for localized aria/placeholder props in Brain,
+  Admin, and onboarding TSX surfaces.
+- Focused runtime wiring modules for model runtime, chat/interaction contexts,
+  and review/Brain tail registration.
+
 ## [6.2.0] - 2026-06-16
 
 > Product Decomposition / Release Smoke Automation. Splits the largest product

package/frontend/src/components/onboarding/AnalysisScreen.tsx

@@ -0,0 +1,127 @@
+import { Sparkles } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import { asArray } from "@/lib/utils";
+import { t, type Language } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+import { asRecord, friendlyModelName, type FlowAnalysis } from "./recommendationModel";
+
+export function AnalysisScreen({
+  analysis,
+  error,
+  onContinue,
+}: {
+  analysis: FlowAnalysis | null;
+  error: string | null;
+  onContinue: () => void;
+}) {
+  const language = useAppStore((state) => state.language);
+  const detected = buildDetectedFacts(analysis, language);
+  return (
+    <div>
+      <div className="ritual-title">{t(language, "flow.analysis.title")}</div>
+      <div className="ritual-subtitle">{t(language, "flow.analysis.body")}</div>
+
+      <div className="ritual-fact-grid">
+        {detected.map((item, idx) => (
+          <div key={idx} className="ritual-fact">
+            <div className="ritual-fact-label">{item.label}</div>
+            <div className="ritual-fact-value">{item.value}</div>
+            <div className="ritual-fact-detail">{item.detail}</div>
+          </div>
+        ))}
+      </div>
+
+      <div className="ritual-card ritual-analysis-card">
+        <div className="ritual-inline-row">
+          <Sparkles className="ritual-core-icon" />
+          <div>
+            <div className="ritual-strong-text">{analysis ? recommendedSummary(analysis, language) : t(language, "flow.analysis.finding")}</div>
+            <div className="ritual-muted-text">
+              {analysis ? t(language, "flow.analysis.ready") : t(language, "flow.analysis.wait")}
+            </div>
+          </div>
+        </div>
+      </div>
+
+      {error && <div className="ritual-card ritual-error-card" role="alert">{error}</div>}
+
+      <div className="ritual-centered-actions">
+        <Button onClick={onContinue} disabled={!analysis && !error} className="ritual-wide-button">
+          {t(language, "flow.analysis.continue")}
+        </Button>
+      </div>
+    </div>
+  );
+}
+
+function buildDetectedFacts(analysis: FlowAnalysis | null, language: Language) {
+  if (!analysis) {
+    return [
+      { label: t(language, "flow.analysis.fact.computer"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.computerDetail") },
+      { label: t(language, "flow.analysis.fact.memory"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.memoryDetail") },
+      { label: t(language, "flow.analysis.fact.graphics"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.graphicsDetail") },
+      { label: t(language, "flow.analysis.fact.support"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.supportDetail") },
+      { label: t(language, "flow.analysis.fact.models"), value: t(language, "flow.analysis.checking"), detail: t(language, "flow.analysis.fact.modelsDetail") },
+    ];
+  }
+  const setupEnv = asRecord(analysis.setup?.environment);
+  const recProfile = asRecord(analysis.recommendations?.profile);
+  const recs = asRecord(analysis.recommendations?.recommendations);
+  const models = asRecord(analysis.models);
+  const sysinfo = asRecord(analysis.sysinfo);
+  const profile = { ...setupEnv, ...recProfile };
+  const ramGb = Number(recs.ram_gb || Number(profile.ram_mb || 0) / 1024 || 0);
+  const appleSilicon = Boolean(recs.apple_silicon || String(profile.arch || "").includes("arm"));
+  const loadedModels = asArray(models.loaded);
+  const gpu = asRecord(profile.gpu);
+  const installedRuntimes = [
+    ...asArray(setupEnv.installed_runtimes),
+    ...asArray(profile.installed_runtimes),
+    ...asArray(recs.installed_runtimes),
+  ];
+  return [
+    {
+      label: t(language, "flow.analysis.fact.computer"),
+      value: appleSilicon ? t(language, "flow.analysis.apple") : friendlyOs(profile.os, language),
+      detail: t(language, "flow.analysis.readyDetail"),
+    },
+    {
+      label: t(language, "flow.analysis.fact.memory"),
+      value: ramGb ? `${Math.round(ramGb)} GB` : t(language, "flow.analysis.detected"),
+      detail: t(language, "flow.analysis.memoryReadyDetail"),
+    },
+    {
+      label: t(language, "flow.analysis.fact.graphics"),
+      value: gpu.vendor || sysinfo.gpu_mem_gb ? t(language, "flow.analysis.localReady") : t(language, "flow.analysis.standardLocal"),
+      detail: t(language, "flow.analysis.graphicsReadyDetail"),
+    },
+    {
+      label: t(language, "flow.analysis.fact.support"),
+      value: installedRuntimes.length ? t(language, "flow.analysis.supportReady") : t(language, "flow.analysis.supportInstall"),
+      detail: installedRuntimes.length ? t(language, "flow.analysis.supportReadyDetail") : t(language, "flow.analysis.supportInstallDetail"),
+    },
+    {
+      label: t(language, "flow.analysis.fact.models"),
+      value: loadedModels.length ? t(language, "flow.analysis.modelsInstalled", { count: loadedModels.length }) : t(language, "flow.analysis.noModels"),
+      detail: loadedModels.length ? t(language, "flow.analysis.modelsReadyDetail") : t(language, "flow.analysis.modelsInstallDetail"),
+    },
+  ];
+}
+
+function recommendedSummary(analysis: FlowAnalysis, language: Language) {
+  const recs = asRecord(analysis.recommendations?.recommendations);
+  const topPick = asRecord(recs.top_pick);
+  if (topPick.name || topPick.id) {
+    const model = friendlyModelName(String(topPick.name || topPick.id));
+    return t(language, "flow.analysis.bestFit", { model });
+  }
+  return t(language, "flow.analysis.privateRecommended");
+}
+
+function friendlyOs(value: unknown, language: Language) {
+  const text = String(value || t(language, "flow.analysis.fact.computer"));
+  if (/darwin|mac/i.test(text)) return "Mac";
+  if (/win/i.test(text)) return t(language, "flow.analysis.os.windows");
+  if (/linux/i.test(text)) return t(language, "flow.analysis.os.linux");
+  return t(language, "flow.analysis.fact.computer");
+}

package/frontend/src/components/onboarding/DownloadConsentPanel.tsx

@@ -0,0 +1,29 @@
+import { t } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+import { type RecommendedModel } from "./recommendationModel";
+
+export function DownloadConsentPanel({ model }: { model: RecommendedModel }) {
+  const language = useAppStore((state) => state.language);
+  const items = [
+    { label: t(language, "flow.consent.size"), value: model.downloadSize || t(language, "flow.consent.sizeUnknown") },
+    { label: t(language, "flow.consent.location"), value: model.storageLocation },
+    { label: t(language, "flow.consent.external"), value: model.externalHost || t(language, "flow.consent.externalNone") },
+  ];
+
+  return (
+    <section className="ritual-consent-panel" aria-label={t(language, "flow.consent.title")}>
+      <div>
+        <strong>{t(language, "flow.consent.title")}</strong>
+        <p>{model.downloadRequired ? t(language, "flow.consent.body") : t(language, "flow.consent.ready")}</p>
+      </div>
+      <dl>
+        {items.map((item) => (
+          <div key={item.label}>
+            <dt>{item.label}</dt>
+            <dd>{item.value}</dd>
+          </div>
+        ))}
+      </dl>
+    </section>
+  );
+}

package/frontend/src/components/onboarding/InstallScreen.tsx

@@ -0,0 +1,208 @@
+import * as React from "react";
+import { CheckCircle2 } from "lucide-react";
+import { latticeApi } from "@/api/client";
+import { type BrainState, LivingBrain } from "@/components/LivingBrain";
+import { Button } from "@/components/ui/button";
+import { asArray } from "@/lib/utils";
+import { t, type Language } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+import { DownloadConsentPanel } from "./DownloadConsentPanel";
+import { asRecord, type ApiData, type RecommendedModel } from "./recommendationModel";
+
+type InstallStage = "idle" | "install" | "download" | "validate" | "load" | "done" | "error";
+
+export function InstallScreen({
+  model,
+  onBack,
+  onComplete,
+  onLater,
+}: {
+  model: RecommendedModel;
+  onBack: () => void;
+  onComplete: () => void;
+  onLater: () => void;
+}) {
+  const language = useAppStore((state) => state.language);
+  const [busy, setBusy] = React.useState(false);
+  const [stage, setStage] = React.useState<InstallStage>("idle");
+  const [percent, setPercent] = React.useState(0);
+  const [message, setMessage] = React.useState(t(language, "flow.install.wait"));
+  const [error, setError] = React.useState<string | null>(null);
+
+  async function start() {
+    setBusy(true);
+    setError(null);
+    setStage("install");
+    setPercent(8);
+    setMessage(t(language, "flow.install.prepare"));
+    const result = await latticeApi.streamModelPrepare(
+      { model: model.loadId, engine: model.engine || "local_mlx", allow_download: true },
+      {
+        onProgress: (event) => {
+          const nextStage = friendlyInstallStage(String(event.stage || ""));
+          setStage(nextStage);
+          setPercent(Number(event.percent || percentForStage(nextStage)));
+          setMessage(friendlyInstallMessage(event, nextStage, language));
+        },
+        onDone: () => {
+          setStage("done");
+          setPercent(100);
+          setMessage(t(language, "flow.install.done"));
+        },
+        onError: (event) => {
+          setStage("error");
+          setError(consumerError(event));
+        },
+      },
+    );
+    setBusy(false);
+    if (result.ok) {
+      setStage("done");
+      setPercent(100);
+      setMessage(t(language, "flow.install.done"));
+      window.setTimeout(onComplete, 700);
+    } else {
+      setStage("error");
+      setError(consumerError(result.data as ApiData));
+    }
+  }
+
+  const brainStateForStage: BrainState =
+    stage === "download" ? "thinking" :
+    stage === "validate" ? "recalling" :
+    stage === "load" ? "synthesizing" :
+    stage === "done" ? "idle" : "listening";
+
+  return (
+    <div>
+      <div className="ritual-title">{t(language, "flow.install.title")}</div>
+      <div className="ritual-subtitle">
+        <strong>{model.shortName}</strong> — {model.reason}.<br />
+        {t(language, "flow.install.body")}
+      </div>
+
+      <div className="ritual-install-brain">
+        <LivingBrain
+          state={brainStateForStage}
+          intensity={stage === "download" || stage === "load" ? 0.96 : 0.82}
+          size="normal"
+        />
+      </div>
+
+      <DownloadConsentPanel model={model} />
+
+      <div className="ritual-progress">
+        <div className="ritual-stage-list">
+          {(["install", "download", "validate", "load"] as const).map((item) => (
+            <div key={item} className={`ritual-stage ${installStepState(stage, item)}`}>
+              <CheckCircle2 className="ritual-stage-icon" />
+              <span>{installLabel(item, language)}</span>
+            </div>
+          ))}
+        </div>
+
+        <div className="ritual-bar">
+          <span className={`ritual-bar-fill ${progressClass(percent)}`} />
+        </div>
+      </div>
+
+      <div className="ritual-status">{message}</div>
+      <div className="ritual-card ritual-status-card">
+        {t(language, "flow.install.note")}
+      </div>
+
+      {error && (
+        <div className="ritual-card ritual-error-card ritual-install-error" role="alert">
+          {error}
+          <div className="ritual-error-detail">{t(language, "flow.install.retry")}</div>
+        </div>
+      )}
+
+      <div className="ritual-button-row">
+        <Button variant="ghost" onClick={onBack} disabled={busy}>{t(language, "flow.install.back")}</Button>
+        <Button variant="outline" onClick={onLater} disabled={busy}>{t(language, "flow.install.later")}</Button>
+
+        {stage !== "done" ? (
+          <Button
+            onClick={start}
+            disabled={busy || !model.supported}
+          >
+            {busy ? t(language, "flow.install.busy") : t(language, "flow.install.start")}
+          </Button>
+        ) : (
+          <Button onClick={onComplete}>{t(language, "flow.install.enter")}</Button>
+        )}
+      </div>
+
+      <div className="ritual-local-note">
+        {t(language, "flow.install.local")}
+      </div>
+    </div>
+  );
+}
+
+function friendlyInstallStage(stage: string): InstallStage {
+  if (/download|pull|weights/i.test(stage)) return "download";
+  if (/smoke|validate|verify|test/i.test(stage)) return "validate";
+  if (/load|ready/i.test(stage)) return "load";
+  if (/done|complete/i.test(stage)) return "done";
+  return "install";
+}
+
+function percentForStage(stage: InstallStage) {
+  if (stage === "install") return 20;
+  if (stage === "download") return 55;
+  if (stage === "validate") return 82;
+  if (stage === "load") return 94;
+  if (stage === "done") return 100;
+  return 8;
+}
+
+function friendlyInstallMessage(event: ApiData, stage: InstallStage, language: Language) {
+  const fallback = {
+    install: t(language, "flow.install.prepare"),
+    download: t(language, "flow.install.stage.download"),
+    validate: t(language, "flow.install.stage.validate"),
+    load: t(language, "flow.install.stage.load"),
+    done: t(language, "flow.install.done"),
+    idle: t(language, "flow.install.wait"),
+    error: t(language, "flow.install.stage.error"),
+  }[stage];
+  return cleanConsumerText(String(event.user_message || event.message || fallback));
+}
+
+function installLabel(stage: "install" | "download" | "validate" | "load", language: Language) {
+  return t(language, `flow.install.step.${stage}`);
+}
+
+function progressClass(percent: number) {
+  const step = Math.max(0, Math.min(100, Math.round(percent / 10) * 10));
+  return `progress-${step}`;
+}
+
+function installStepState(current: InstallStage, item: "install" | "download" | "validate" | "load") {
+  const order: InstallStage[] = ["idle", "install", "download", "validate", "load", "done"];
+  const currentIndex = order.indexOf(current);
+  const itemIndex = order.indexOf(item);
+  if (current === "error") return "is-error";
+  if (current === "done" || currentIndex > itemIndex) return "is-done";
+  if (current === item) return "is-active";
+  return "";
+}
+
+function consumerError(data: ApiData | unknown) {
+  const record = asRecord(data);
+  const guidance = asArray<string>(record.recovery_guidance).map(cleanConsumerText).filter(Boolean);
+  const message = cleanConsumerText(String(record.user_message || record.reason || record.error || "The selected model could not be loaded."));
+  return [message, ...guidance.slice(0, 2)].join(" ");
+}
+
+function cleanConsumerText(value: string) {
+  return String(value || "")
+    .replace(/gemma4_unified/gi, "this model format")
+    .replace(/mlx[-_ ]?vlm|mlx[-_ ]?lm|local_mlx|\bmlx\b|\bgguf\b|\bollama\b|huggingface|hugging face/gi, "local model support")
+    .replace(/runtime/gi, "model support")
+    .replace(/No module named ['\"][^'\"]+['\"]/gi, "A local support component is missing")
+    .replace(/\s+/g, " ")
+    .trim();
+}

package/frontend/src/components/onboarding/LanguageChooser.tsx

@@ -0,0 +1,23 @@
+import { LANGUAGE_LABELS, t, type Language } from "@/i18n";
+import { useAppStore } from "@/store/appStore";
+
+export function LanguageChooser() {
+  const language = useAppStore((state) => state.language);
+  const setLanguage = useAppStore((state) => state.setLanguage);
+
+  return (
+    <div className="language-switcher ritual-language" aria-label={t(language, "language.label")}>
+      {(["ko", "en"] as Language[]).map((item) => (
+        <button
+          key={item}
+          type="button"
+          className={language === item ? "is-active" : ""}
+          onClick={() => setLanguage(item)}
+          aria-pressed={language === item}
+        >
+          {LANGUAGE_LABELS[item]}
+        </button>
+      ))}
+    </div>
+  );
+}