@agentprojectcontext/apx 1.66.0 → 1.68.0

package/src/interfaces/web/src/components/settings/RoutingPanel.tsx

@@ -0,0 +1,236 @@
+import { useEffect, useMemo, useState, type ReactNode } from "react";
+import { Route as RouteIcon, Image, Ruler, Radio, Hash, ChevronRight } from "lucide-react";
+import { Section } from "../Section";
+import { Badge, Button, Dialog, Field, Loading, Switch, Textarea, Tip } from "../ui";
+import { useToast } from "../Toast";
+import { useGlobalConfig } from "../../hooks/useGlobalConfig";
+import { t } from "../../i18n";
+
+// Content-based model routing (OpenHands RouterLLM pattern). NOT the failover
+// router (that is DefaultRouterCard). Here each rule prefers a model for a turn
+// based on features (image/size/channel/keywords); it composes with failover —
+// a routed model that is down still falls back down the regular chain.
+interface RoutingWhen {
+  has_image?: boolean;
+  min_prompt_chars?: number;
+  max_prompt_chars?: number;
+  min_context_chars?: number;
+  channels?: string[];
+  keywords?: string[];
+}
+interface RoutingRule {
+  model: string;
+  when?: RoutingWhen;
+}
+
+const EXAMPLE_RULES: RoutingRule[] = [
+  { model: "openai:gpt-4o", when: { has_image: true } },
+  { model: "anthropic:claude-3-5-haiku", when: { max_prompt_chars: 400 } },
+];
+
+// Render a rule's `when` block as readable condition chips.
+function WhenChips({ when }: { when?: RoutingWhen }) {
+  const chips: { icon: ReactNode; label: string }[] = [];
+  if (!when || Object.keys(when).length === 0) {
+    chips.push({ icon: <ChevronRight size={11} />, label: t("routing_panel.when_any") });
+  } else {
+    if (when.has_image === true) chips.push({ icon: <Image size={11} />, label: t("routing_panel.when_image") });
+    if (when.has_image === false) chips.push({ icon: <Image size={11} />, label: t("routing_panel.when_no_image") });
+    if (Number.isFinite(when.min_prompt_chars))
+      chips.push({ icon: <Ruler size={11} />, label: t("routing_panel.when_min_prompt", { n: String(when.min_prompt_chars) }) });
+    if (Number.isFinite(when.max_prompt_chars))
+      chips.push({ icon: <Ruler size={11} />, label: t("routing_panel.when_max_prompt", { n: String(when.max_prompt_chars) }) });
+    if (Number.isFinite(when.min_context_chars))
+      chips.push({ icon: <Ruler size={11} />, label: t("routing_panel.when_min_context", { n: String(when.min_context_chars) }) });
+    if (Array.isArray(when.channels) && when.channels.length > 0)
+      chips.push({ icon: <Radio size={11} />, label: t("routing_panel.when_channels", { list: when.channels.join(", ") }) });
+    if (Array.isArray(when.keywords) && when.keywords.length > 0)
+      chips.push({ icon: <Hash size={11} />, label: t("routing_panel.when_keywords", { list: when.keywords.join(", ") }) });
+  }
+  return (
+    <div className="flex flex-wrap items-center gap-1.5">
+      {chips.map((c, i) => (
+        <span key={i} className="inline-flex items-center gap-1 rounded bg-muted px-1.5 py-0.5 text-[11px] text-muted-fg">
+          {c.icon} {c.label}
+        </span>
+      ))}
+    </div>
+  );
+}
+
+export function RoutingPanel() {
+  const toast = useToast();
+  const { config, isLoading, patch } = useGlobalConfig();
+
+  const [enabled, setEnabled] = useState(false);
+  const [rulesText, setRulesText] = useState("[]");
+  const [editing, setEditing] = useState(false);
+  const [busy, setBusy] = useState(false);
+  const [confirmOpen, setConfirmOpen] = useState(false);
+  // Snapshot of the saved state, for dirty tracking.
+  const [saved, setSaved] = useState<{ enabled: boolean; rulesText: string }>({ enabled: false, rulesText: "[]" });
+
+  useEffect(() => {
+    const routing = (config.super_agent?.routing || {}) as { enabled?: boolean; rules?: RoutingRule[] };
+    const rules = Array.isArray(routing.rules) ? routing.rules : [];
+    const text = JSON.stringify(rules, null, 2);
+    setEnabled(routing.enabled === true);
+    setRulesText(text);
+    setSaved({ enabled: routing.enabled === true, rulesText: text });
+  }, [config.super_agent?.routing]);
+
+  // Parse the editor buffer live: the list preview and save both use this.
+  const parsed = useMemo<{ rules: RoutingRule[]; error: string | null }>(() => {
+    try {
+      const v = JSON.parse(rulesText);
+      if (!Array.isArray(v)) return { rules: [], error: t("routing_panel.json_not_array") };
+      return { rules: v as RoutingRule[], error: null };
+    } catch (e) {
+      return { rules: [], error: t("routing_panel.json_error", { msg: (e as Error).message }) };
+    }
+  }, [rulesText]);
+
+  if (isLoading) return <Loading />;
+
+  const rules = parsed.rules;
+  const ruleCount = rules.length;
+  // Normalize for dirty compare so whitespace-only edits don't count.
+  const normalizedText = parsed.error ? rulesText : JSON.stringify(rules);
+  const savedNormalized = (() => { try { return JSON.stringify(JSON.parse(saved.rulesText)); } catch { return saved.rulesText; } })();
+  const dirty = enabled !== saved.enabled || normalizedText !== savedNormalized;
+
+  const doSave = async () => {
+    if (parsed.error) return;
+    setBusy(true);
+    try {
+      await patch({ "super_agent.routing": { enabled, rules } });
+      toast.success(t("routing_panel.saved_toast"));
+      const text = JSON.stringify(rules, null, 2);
+      setRulesText(text);
+      setSaved({ enabled, rulesText: text });
+    } catch (e) {
+      toast.error((e as Error).message);
+    } finally {
+      setBusy(false);
+      setConfirmOpen(false);
+    }
+  };
+
+  const signalOn = enabled && ruleCount > 0;
+
+  return (
+    <div data-testid="routing-panel">
+      <Section title={t("routing_panel.title")} description={t("routing_panel.description")}>
+        <div className="space-y-4">
+          {/* Active/inactive signal — the user wants a clear "it's on" cue. */}
+          <div className="flex flex-wrap items-center gap-2 rounded-lg border border-border bg-muted/20 p-3">
+            <span data-testid="routing-signal">
+              {signalOn ? (
+                <Badge tone="success">
+                  <RouteIcon size={11} /> {t("routing_panel.signal_on", { n: String(ruleCount) })}
+                </Badge>
+              ) : enabled ? (
+                <Badge tone="warning">
+                  <RouteIcon size={11} /> {t("routing_panel.signal_on_empty")}
+                </Badge>
+              ) : (
+                <Badge tone="muted">
+                  <RouteIcon size={11} /> {t("routing_panel.signal_off")}
+                </Badge>
+              )}
+            </span>
+            <Tip content={t("routing_panel.helper")}>
+              <span className="text-xs text-muted-fg underline decoration-dotted underline-offset-2">
+                {t("routing_panel.how_it_works")}
+              </span>
+            </Tip>
+          </div>
+
+          <Switch checked={enabled} onChange={setEnabled} label={t("routing_panel.enable_label")} />
+
+          {/* Rules preview */}
+          <div className="rounded-lg border border-border bg-muted/20 p-3">
+            <div className="mb-2 flex items-center justify-between gap-2">
+              <div>
+                <div className="text-sm font-medium">{t("routing_panel.rules_title")}</div>
+                <div className="text-xs text-muted-fg">{t("routing_panel.rules_desc")}</div>
+              </div>
+              <Button size="sm" variant="secondary" onClick={() => setEditing((v) => !v)}>
+                {editing ? t("routing_panel.hide_editor") : t("routing_panel.edit_rules")}
+              </Button>
+            </div>
+
+            <ul className="space-y-1.5">
+              {rules.map((r, i) => (
+                <li key={i} className="rounded-md bg-card px-2.5 py-2 text-xs">
+                  <div className="mb-1 flex items-center gap-2">
+                    <span className="w-6 text-muted-fg">#{i + 1}</span>
+                    <span className="font-mono text-[12px]">{r.model || "—"}</span>
+                  </div>
+                  <div className="pl-8">
+                    <WhenChips when={r.when} />
+                  </div>
+                </li>
+              ))}
+              {ruleCount === 0 && !parsed.error && (
+                <li className="text-xs text-muted-fg">{t("routing_panel.rules_empty")}</li>
+              )}
+            </ul>
+          </div>
+
+          {/* JSON editor for the rules array */}
+          {editing && (
+            <Field label={t("routing_panel.editor_label")} hint={t("routing_panel.json_hint")}>
+              <Textarea
+                rows={10}
+                className="font-mono text-xs"
+                value={rulesText}
+                onChange={(e) => setRulesText(e.target.value)}
+                spellCheck={false}
+              />
+              {parsed.error ? (
+                <span className="mt-1 block text-[11px] text-red-400">{parsed.error}</span>
+              ) : (
+                <button
+                  type="button"
+                  className="mt-1 text-[11px] text-muted-fg underline decoration-dotted underline-offset-2"
+                  onClick={() => setRulesText(JSON.stringify(EXAMPLE_RULES, null, 2))}
+                >
+                  {t("routing_panel.insert_example")}
+                </button>
+              )}
+            </Field>
+          )}
+
+          <p className="text-[11px] leading-relaxed text-muted-fg">{t("routing_panel.helper")}</p>
+
+          <Button
+            variant="primary"
+            loading={busy}
+            disabled={!dirty || !!parsed.error}
+            onClick={() => setConfirmOpen(true)}
+          >
+            {dirty ? t("routing_panel.save") : t("routing_panel.saved")}
+          </Button>
+        </div>
+      </Section>
+
+      <Dialog
+        open={confirmOpen}
+        onClose={() => setConfirmOpen(false)}
+        title={t("routing_panel.confirm_title")}
+        description={t("routing_panel.confirm_body")}
+        footer={
+          <>
+            <Button variant="ghost" onClick={() => setConfirmOpen(false)}>{t("routing_panel.cancel")}</Button>
+            <Button variant="primary" loading={busy} onClick={doSave}>{t("routing_panel.confirm_apply")}</Button>
+          </>
+        }
+      >
+        <p className="text-sm text-muted-fg">
+          {enabled ? t("routing_panel.confirm_on", { n: String(ruleCount) }) : t("routing_panel.confirm_off")}
+        </p>
+      </Dialog>
+    </div>
+  );
+}

package/src/interfaces/web/src/i18n/en.ts

@@ -711,6 +711,8 @@ export const en = {
       save_fields_success: "Overrides saved.",
       save_meta_success: "Project metadata saved.",
       no_data:     "No data.",
+      tab_settings: "Settings",
+      tab_project:  "Project",
     },
 
     telegram: {
@@ -731,6 +733,9 @@ export const en = {
     },
 
     memories: {
+      sidebar_title:   "Memories",
+      general_group:   "General",
+      general_item:    "Project memory",
       project_title:   "Project memory",
       project_desc:    "Durable facts at the project level. .apc/memory.md — read by agents and the super-agent.",
       project_ph:      "# Project Memory\n\nStable facts that any agent should know…",
@@ -756,6 +761,7 @@ export const en = {
     workspaces_empty:   "No projects. Add one with the button above.",
     sessions_title:     "Sessions",
     sessions_desc:      "Sessions from all engines (apx · claude · codex), newest first.",
+    sessions_desc_scoped: "Sessions in this project's folder ({path}), all engines, newest first.",
     sessions_all:       "All engines",
     sessions_empty:     "No sessions.",
     sessions_error:     "Could not read sessions: {msg}",
@@ -976,6 +982,15 @@ export const en = {
     artifacts_rename:    "Rename",
     artifacts_view:      "View contents",
     artifacts_edit:      "Edit contents",
+    artifacts_preview:       "Preview",
+    artifacts_preview_hint:  "Open a live preview in a local browser tab",
+    artifacts_share:         "Share",
+    artifacts_share_hint:    "Create a public tunnel URL to share this preview",
+    artifacts_stop_preview:  "Stop preview",
+    artifacts_preview_local: "Local preview",
+    artifacts_preview_public:"Public URL",
+    artifacts_copy_url:      "Copy URL",
+    artifacts_preview_started: "Preview running at {url}",
     tree_collapse_all:   "Collapse all",
     terminal_clear:      "Clear",
     terminal_close:      "Close terminal",
@@ -1077,6 +1092,44 @@ export const en = {
     provider_not_configured: "The provider \"{name}\" is not configured.",
   },
 
+  routing_panel: {
+    title:            "Content routing",
+    description:      "Prefer a different model per message based on its content (image, size, channel, keywords). Separate from the fallback chain above.",
+    signal_on:        "Content routing: ON ({n} rules)",
+    signal_on_empty:  "Content routing: ON (no rules yet)",
+    signal_off:       "Content routing: OFF",
+    how_it_works:     "How does it work?",
+    enable_label:     "Enable content routing",
+    rules_title:      "Routing rules",
+    rules_desc:       "Evaluated top to bottom; the first rule whose conditions all match wins.",
+    rules_empty:      "No rules yet. Add some in the editor.",
+    edit_rules:       "Edit rules (JSON)",
+    hide_editor:      "Hide editor",
+    editor_label:     "Rules (JSON array)",
+    json_hint:        "Array of { model, when }. when keys: has_image, min_prompt_chars, max_prompt_chars, min_context_chars, channels[], keywords[]. Empty when = matches every message.",
+    json_error:       "Invalid JSON: {msg}",
+    json_not_array:   "The rules must be a JSON array.",
+    insert_example:   "Insert an example",
+    when_any:         "any message",
+    when_image:       "has image",
+    when_no_image:    "no image",
+    when_min_prompt:  "prompt ≥ {n} chars",
+    when_max_prompt:  "prompt ≤ {n} chars",
+    when_min_context: "context ≥ {n} chars",
+    when_channels:    "channels: {list}",
+    when_keywords:    "keywords: {list}",
+    helper:           "Routing picks a model per message (image, size, channel, keywords). It composes with failover: a routed model that is down falls back down the chain. An explicit per-request model override always wins.",
+    save:             "Save routing",
+    saved:            "Saved",
+    saved_toast:      "Content routing saved.",
+    confirm_title:    "Apply routing changes?",
+    confirm_body:     "This changes which model handles each message. Failover still applies if a routed model is down.",
+    confirm_on:       "Content routing will be ON with {n} rules.",
+    confirm_off:      "Content routing will be OFF (every message uses the default router).",
+    confirm_apply:    "Apply",
+    cancel:           "Cancel",
+  },
+
   engines_panel: {
     title:               "Providers",
     new_btn:             "New provider",

package/src/interfaces/web/src/i18n/es.ts

@@ -709,6 +709,8 @@ export const es = {
       save_fields_success: "Overrides guardados.",
       save_meta_success: "Project metadata guardado.",
       no_data:     "Sin datos.",
+      tab_settings: "Settings",
+      tab_project:  "Project",
     },
 
     telegram: {
@@ -729,6 +731,9 @@ export const es = {
     },
 
     memories: {
+      sidebar_title:   "Memorias",
+      general_group:   "General",
+      general_item:    "Memoria del proyecto",
       project_title:   "Memoria del proyecto",
       project_desc:    "Hechos durables a nivel proyecto. .apc/memory.md — la leen los agentes y el super-agente.",
       project_ph:      "# Memoria del proyecto\n\nHechos estables que cualquier agente debería saber…",
@@ -754,6 +759,7 @@ export const es = {
     workspaces_empty:   "Sin proyectos. Agregá uno con el botón de arriba.",
     sessions_title:     "Sessions",
     sessions_desc:      "Sesiones de todos los engines (apx · claude · codex), más nuevas primero.",
+    sessions_desc_scoped: "Sesiones en la carpeta de este proyecto ({path}), todos los engines, más nuevas primero.",
     sessions_all:       "Todos los engines",
     sessions_empty:     "Sin sesiones.",
     sessions_error:     "No pude leer las sesiones: {msg}",
@@ -974,6 +980,15 @@ export const es = {
     artifacts_rename:    "Renombrar",
     artifacts_view:      "Ver contenido",
     artifacts_edit:      "Editar contenido",
+    artifacts_preview:       "Previsualizar",
+    artifacts_preview_hint:  "Abrir una previsualización en vivo en una pestaña local",
+    artifacts_share:         "Compartir",
+    artifacts_share_hint:    "Crear una URL pública por túnel para compartir esta preview",
+    artifacts_stop_preview:  "Detener preview",
+    artifacts_preview_local: "Preview local",
+    artifacts_preview_public:"URL pública",
+    artifacts_copy_url:      "Copiar URL",
+    artifacts_preview_started: "Preview activa en {url}",
     tree_collapse_all:   "Colapsar todo",
     terminal_clear:      "Limpiar",
     terminal_close:      "Cerrar terminal",
@@ -1075,6 +1090,44 @@ export const es = {
     provider_not_configured: "El proveedor \"{name}\" no está configurado.",
   },
 
+  routing_panel: {
+    title:            "Ruteo por contenido",
+    description:      "Elegí un modelo distinto por mensaje según su contenido (imagen, tamaño, canal, keywords). Aparte de la cadena de fallback de arriba.",
+    signal_on:        "Ruteo por contenido: ON ({n} reglas)",
+    signal_on_empty:  "Ruteo por contenido: ON (todavía sin reglas)",
+    signal_off:       "Ruteo por contenido: OFF",
+    how_it_works:     "¿Cómo funciona?",
+    enable_label:     "Activar ruteo por contenido",
+    rules_title:      "Reglas de ruteo",
+    rules_desc:       "Se evalúan de arriba hacia abajo; gana la primera regla que cumpla todas sus condiciones.",
+    rules_empty:      "Todavía sin reglas. Agregá algunas en el editor.",
+    edit_rules:       "Editar reglas (JSON)",
+    hide_editor:      "Ocultar editor",
+    editor_label:     "Reglas (array JSON)",
+    json_hint:        "Array de { model, when }. Claves de when: has_image, min_prompt_chars, max_prompt_chars, min_context_chars, channels[], keywords[]. when vacío = matchea todos los mensajes.",
+    json_error:       "JSON inválido: {msg}",
+    json_not_array:   "Las reglas tienen que ser un array JSON.",
+    insert_example:   "Insertar un ejemplo",
+    when_any:         "cualquier mensaje",
+    when_image:       "tiene imagen",
+    when_no_image:    "sin imagen",
+    when_min_prompt:  "prompt ≥ {n} chars",
+    when_max_prompt:  "prompt ≤ {n} chars",
+    when_min_context: "contexto ≥ {n} chars",
+    when_channels:    "canales: {list}",
+    when_keywords:    "keywords: {list}",
+    helper:           "El ruteo elige un modelo por mensaje (imagen, tamaño, canal, keywords). Se compone con el failover: un modelo ruteado que esté caído cae por la cadena. Un override de modelo explícito por request siempre gana.",
+    save:             "Guardar ruteo",
+    saved:            "Guardado",
+    saved_toast:      "Ruteo por contenido guardado.",
+    confirm_title:    "¿Aplicar los cambios de ruteo?",
+    confirm_body:     "Esto cambia qué modelo atiende cada mensaje. El failover sigue aplicando si un modelo ruteado está caído.",
+    confirm_on:       "El ruteo por contenido va a quedar ON con {n} reglas.",
+    confirm_off:      "El ruteo por contenido va a quedar OFF (cada mensaje usa el router default).",
+    confirm_apply:    "Aplicar",
+    cancel:           "Cancelar",
+  },
+
   engines_panel: {
     title:               "Proveedores",
     new_btn:             "Nuevo proveedor",

package/src/interfaces/web/src/lib/api/artifacts.ts

@@ -28,6 +28,29 @@ export interface ArtifactRunResult {
   error?: string;
 }
 
+// A running ephemeral preview server for an artifact. `url` is the local
+// http://localhost:<port>/ address; `tunnel` is set once shared publicly.
+export interface ArtifactPreview {
+  id: string;
+  projectId: string | number | null;
+  name: string;
+  kind: "html" | "react" | "static" | "text";
+  port: number;
+  url: string;
+  watch: boolean;
+  createdAt: string;
+  hits: number;
+  tunnel: { id: string; url: string; provider: string } | null;
+}
+
+export interface ArtifactTunnel {
+  id: string;
+  url: string;
+  provider: string;
+  port: number;
+  createdAt: string;
+}
+
 export const Artifacts = {
   list: (pid: string) =>
     http.get<ArtifactEntry[]>(`/projects/${encodeURIComponent(pid)}/artifacts`),
@@ -54,4 +77,19 @@ export const Artifacts = {
       `/projects/${encodeURIComponent(pid)}/artifacts/${encodeURIComponent(name)}`,
       { newName },
     ),
+
+  // Start (or reuse) an ephemeral local preview server for an artifact.
+  preview: (pid: string, name: string, watch = true) =>
+    http.post<ArtifactPreview>(
+      `/projects/${encodeURIComponent(pid)}/artifacts/${encodeURIComponent(name)}/preview`,
+      { watch },
+    ),
+  // List running preview servers for a project.
+  previews: (pid: string) =>
+    http.get<ArtifactPreview[]>(`/projects/${encodeURIComponent(pid)}/previews`),
+  stopPreview: (id: string) => http.del<void>(`/previews/${encodeURIComponent(id)}`),
+  // Open / close a public tunnel to a running preview.
+  openTunnel: (id: string, provider?: string) =>
+    http.post<ArtifactTunnel>(`/previews/${encodeURIComponent(id)}/tunnel`, { provider }),
+  closeTunnel: (id: string) => http.del<void>(`/previews/${encodeURIComponent(id)}/tunnel`),
 };

package/src/interfaces/web/src/lib/api/sessions.ts

@@ -19,11 +19,12 @@ export const Sessions = {
       .then((b) => ({ sessions: unwrapPage<SessionRow>(b).items })),
   // Server-paginated page. Optional `q` runs the same search core as
   // `apx session find` (title; + transcript content when `deep`).
-  page: ({ engine, q, deep, limit, offset }: { engine?: string; q?: string; deep?: boolean; limit: number; offset: number }) => {
+  page: ({ engine, q, deep, cwd, limit, offset }: { engine?: string; q?: string; deep?: boolean; cwd?: string; limit: number; offset: number }) => {
     const params = new URLSearchParams({ limit: String(limit), offset: String(offset) });
     if (engine) params.set("engine", engine);
     if (q?.trim()) params.set("q", q.trim());
     if (deep) params.set("deep", "1");
+    if (cwd?.trim()) params.set("cwd", cwd.trim());
     return http.get<unknown>(`/sessions?${params.toString()}`).then((b) => unwrapPage<SessionRow>(b));
   },
 };

package/src/interfaces/web/src/screens/ProjectScreen.tsx

@@ -1,8 +1,8 @@
 import { useMemo } from "react";
 import { useParams, Routes, Route, Navigate, useLocation, useNavigate } from "react-router-dom";
 import {
-  Bot, Heart, Zap, Puzzle, FolderKanban, Settings,
-  MessagesSquare, Send, KeyRound,
+  Bot, Heart, Zap, Puzzle, Settings,
+  MessagesSquare, KeyRound,
   LayoutDashboard, Boxes, Cpu, ScrollText, History, Brain, FileCode2, Cable,
   Building2, FileText, FolderTree, Sparkles,
 } from "lucide-react";
@@ -40,7 +40,7 @@ import { SkillsTab } from "./project/SkillsTab";
 type NavKey =
   | "" | "chat" | "config" | "telegram"
   | "agents" | "routines" | "tasks" | "mcps" | "integrations" | "vars" | "logs" | "memories" | "artifacts"
-  | "structure" | "docs" | "files" | "skills";
+  | "structure" | "docs" | "files" | "skills" | "sessions";
 
 export function ProjectScreen() {
   const navigate = useNavigate();
@@ -51,85 +51,75 @@ export function ProjectScreen() {
 
   const isBase = String(pid) === "0";
   const sections: TabSection[] = useMemo(() => {
-    if (isBase) {
-      // Base = menú global / admin del daemon (distinto al de un proyecto).
-      return [
-        {
-          title: t("base.nav_general"),
-          items: [
-            { key: "",               label: "Dashboard",                    icon: LayoutDashboard },
-            { key: "workspaces",     label: t("base.workspaces_title"),     icon: Boxes },
-            { key: "models",         label: t("settings.tabs.engines"),     icon: Cpu },
-            { key: "agent-defaults", label: t("base.defaults_title"),       icon: Bot },
-          ],
-        },
-        {
-          title: t("base.nav_activity"),
-          items: [
-            { key: "chat",     label: t("project.nav.chat"),     icon: MessagesSquare },
-            { key: "sessions", label: t("base.sessions_title"),  icon: History },
-            { key: "tasks",    label: t("project.nav.tasks"),    icon: Zap },
-            { key: "logs",     label: t("project.nav.logs"),     icon: ScrollText },
-          ],
-        },
-        {
-          title: t("base.nav_system"),
-          items: [
-            { key: "agents",   label: t("project.nav.agents"),   icon: Bot },
-            { key: "memories", label: t("project.nav.memories"), icon: Brain },
-            { key: "skills",   label: t("skills_page.title"),    icon: Sparkles },
-            { key: "routines",  label: t("project.nav.routines"),  icon: Heart },
-            { key: "mcps",      label: t("project.nav.mcps"),      icon: Puzzle },
-            { key: "integrations", label: "Integrations",          icon: Cable },
-            { key: "vars",      label: t("project.nav.vars"),      icon: KeyRound },
-            { key: "artifacts", label: t("project.nav.artifacts"), icon: FileCode2 },
-            { key: "config",    label: t("project.nav.config"),    icon: Settings },
-          ],
-        },
-      ];
-    }
-    // Structure (org roles/areas) is only meaningful for company/enterprise
-    // projects — gate it on the project kind.
-    const isCompany = project?.kind === "company";
-    return [
+    // One shared taxonomy for both Base and projects, in the same order, so the
+    // two menus mirror each other. Base additionally gets a "General" admin
+    // section (workspaces / engines / agent defaults) and drops "Content"
+    // (no docs/files surface). "Workspace" and "Automation" are identical on
+    // both. Structure (org roles/areas) only makes sense for company projects.
+    const isCompany = !isBase && project?.kind === "company";
+
+    const out: (TabSection | null)[] = [
+      // General — Base-only daemon admin.
+      isBase ? {
+        title: t("base.nav_general"),
+        items: [
+          { key: "workspaces",     label: t("base.workspaces_title"), icon: Boxes },
+          { key: "models",         label: t("settings.tabs.engines"), icon: Cpu },
+          { key: "agent-defaults", label: t("base.defaults_title"),   icon: Bot },
+        ],
+      } : null,
+      // Workspace — the overview plus the team's own building blocks
+      // (agents / memories / skills / artifacts). "Overview" on both sides.
       {
         title: t("project.sections.workspace"),
         items: [
-          { key: "",         label: t("project.nav.overview"),  icon: FolderKanban },
-          { key: "telegram", label: t("project.nav.telegram"),  icon: Send },
-          { key: "chat",     label: t("project.nav.chat"),      icon: MessagesSquare },
-          { key: "agents",   label: t("project.nav.agents"),    icon: Bot },
+          { key: "", label: t("project.nav.overview"), icon: LayoutDashboard },
           ...(isCompany ? [{ key: "structure", label: t("project.nav.structure"), icon: Building2 }] : []),
-          { key: "memories", label: t("project.nav.memories"),  icon: Brain },
-          { key: "skills",   label: t("skills_page.title"),     icon: Sparkles },
+          { key: "agents",    label: t("project.nav.agents"),    icon: Bot },
+          { key: "memories",  label: t("project.nav.memories"),  icon: Brain },
+          { key: "skills",    label: t("skills_page.title"),     icon: Sparkles },
+          { key: "artifacts", label: t("project.nav.artifacts"), icon: FileCode2 },
         ],
       },
+      // Activity — chat / sessions / logs.
       {
+        title: t("base.nav_activity"),
+        items: [
+          { key: "chat", label: t("project.nav.chat"), icon: MessagesSquare },
+          { key: "sessions", label: t("base.sessions_title"), icon: History },
+          { key: "logs", label: t("project.nav.logs"), icon: ScrollText },
+        ],
+      },
+      // Content — docs / files. Project-only (Base has no such surface).
+      !isBase ? {
         title: t("project.sections.content"),
         items: [
           { key: "docs",  label: t("project.nav.docs"),  icon: FileText },
           { key: "files", label: t("project.nav.files"), icon: FolderTree },
         ],
-      },
+      } : null,
+      // Automation — routines / tasks / mcps / integrations / vars.
+      // Identical on both sides.
       {
         title: t("project.sections.automation"),
         items: [
-          { key: "routines",  label: t("project.nav.routines"),  icon: Heart },
-          { key: "tasks",     label: t("project.nav.tasks"),     icon: Zap },
-          { key: "mcps",      label: t("project.nav.mcps"),      icon: Puzzle },
-          { key: "integrations", label: "Integrations",          icon: Cable },
-          { key: "vars",      label: t("project.nav.vars"),      icon: KeyRound },
-          { key: "artifacts", label: t("project.nav.artifacts"), icon: FileCode2 },
-          { key: "logs",      label: t("project.nav.logs"),      icon: ScrollText },
+          { key: "routines",     label: t("project.nav.routines"),  icon: Heart },
+          { key: "tasks",        label: t("project.nav.tasks"),     icon: Zap },
+          { key: "mcps",         label: t("project.nav.mcps"),      icon: Puzzle },
+          { key: "integrations", label: "Integrations",             icon: Cable },
+          { key: "vars",         label: t("project.nav.vars"),      icon: KeyRound },
         ],
       },
+      // Config — the general project/daemon config.
       {
         title: t("project.sections.config"),
         items: [
-          { key: "config",   label: t("project.nav.config"),    icon: Settings },
+          { key: "config", label: t("project.nav.config"), icon: Settings },
         ],
       },
     ];
+
+    return out.filter(Boolean) as TabSection[];
   }, [isBase, project?.kind]);
 
   // First path segment after /p/:pid — so deep routes like agents/:slug still
@@ -171,7 +161,7 @@ export function ProjectScreen() {
         <Route path="workspaces"   element={<WorkspacesTab />} />
         <Route path="models"       element={<ModelsTab />} />
         <Route path="agent-defaults" element={<AgentDefaultsTab />} />
-        <Route path="sessions"     element={<SessionsTab />} />
+        <Route path="sessions"     element={<SessionsTab pid={pid} />} />
         <Route path="logs"         element={<LogsTab pid={pid} />} />
         <Route path="config"       element={<ConfigTab pid={pid} />} />
         <Route path="telegram"     element={<TelegramTab pid={pid} />} />

package/src/interfaces/web/src/screens/base/ModelsTab.tsx

@@ -1,12 +1,14 @@
 import { DefaultRouterCard } from "../../components/settings/DefaultRouterCard";
+import { RoutingPanel } from "../../components/settings/RoutingPanel";
 import { EnginesPanel } from "../../components/settings/EnginesPanel";
 
-// Base "Models" page: general default router (no per-task cases) on top of the
-// provider list. EnginesPanel is reused as-is from Settings.
+// Base "Models" page: default failover router + content-based routing on top of
+// the provider list. EnginesPanel is reused as-is from Settings.
 export function ModelsTab() {
   return (
     <div className="space-y-6">
       <DefaultRouterCard />
+      <RoutingPanel />
       <EnginesPanel />
     </div>
   );