feat: star + tag sessions

- Backend
  - LabelStore (Arc<RwLock<HashMap>>) persisted to
    ~/.pawscope/labels.json on every change
  - GET /api/labels returns the full map
  - POST /api/labels/{id} body { starred, tags }
    Normalizes tags: trims, strips empties, caps at 16 tags,
    each tag <= 32 chars. Empty labels are removed from store.
- Frontend
  - SessionList: ☆/★ toggle on each row, tag chips inline,
    new ★-only filter, clickable tag pill row
  - SessionDetail: ★ button in header, tag editor below
    header (chips + Enter-to-add)
  - Labels loaded once at startup; in-memory map shared
    across all panels; updates fire async POST.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: anbei.yuan

Cargo.lock

@@ -19,6 +19,7 @@ mime_guess = "2"
 futures = "0.3"
 tokio-stream = { version = "0.1", features = ["sync"] }
 chrono = { version = "0.4", features = ["serde"] }
+dirs = "5"
 
 [dev-dependencies]
 reqwest = { version = "0.12", features = ["json"] }

crates/pawscope-server/Cargo.toml

@@ -669,3 +669,28 @@ pub async fn tools_bucket(
 
     Json(hits).into_response()
 }
+
+pub async fn list_labels(State(s): State<AppState>) -> impl IntoResponse {
+    Json(s.labels.snapshot().await).into_response()
+}
+
+pub async fn set_label(
+    Path(id): Path<String>,
+    State(s): State<AppState>,
+    Json(label): Json<crate::labels::Label>,
+) -> impl IntoResponse {
+    let normalized = crate::labels::Label {
+        starred: label.starred,
+        tags: label
+            .tags
+            .into_iter()
+            .map(|t| t.trim().to_string())
+            .filter(|t| !t.is_empty() && t.len() <= 32)
+            .take(16)
+            .collect(),
+    };
+    match s.labels.set(&id, normalized.clone()).await {
+        Ok(()) => Json(normalized).into_response(),
+        Err(e) => (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()).into_response(),
+    }
+}

crates/pawscope-server/src/api.rs

@@ -0,0 +1,79 @@
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+pub struct Label {
+    #[serde(default)]
+    pub starred: bool,
+    #[serde(default)]
+    pub tags: Vec<String>,
+}
+
+impl Label {
+    pub fn is_empty(&self) -> bool {
+        !self.starred && self.tags.is_empty()
+    }
+}
+
+#[derive(Clone)]
+pub struct LabelStore {
+    path: PathBuf,
+    inner: Arc<RwLock<HashMap<String, Label>>>,
+}
+
+fn default_path() -> PathBuf {
+    dirs::home_dir()
+        .unwrap_or_else(|| PathBuf::from("."))
+        .join(".pawscope")
+        .join("labels.json")
+}
+
+impl LabelStore {
+    pub async fn load() -> Self {
+        Self::load_from(default_path()).await
+    }
+
+    pub async fn load_from(path: PathBuf) -> Self {
+        let map = tokio::fs::read_to_string(&path)
+            .await
+            .ok()
+            .and_then(|s| serde_json::from_str::<HashMap<String, Label>>(&s).ok())
+            .unwrap_or_default();
+        Self {
+            path,
+            inner: Arc::new(RwLock::new(map)),
+        }
+    }
+
+    pub async fn snapshot(&self) -> HashMap<String, Label> {
+        self.inner.read().await.clone()
+    }
+
+    pub async fn get(&self, id: &str) -> Label {
+        self.inner.read().await.get(id).cloned().unwrap_or_default()
+    }
+
+    pub async fn set(&self, id: &str, label: Label) -> std::io::Result<()> {
+        {
+            let mut g = self.inner.write().await;
+            if label.is_empty() {
+                g.remove(id);
+            } else {
+                g.insert(id.to_string(), label);
+            }
+        }
+        self.persist().await
+    }
+
+    async fn persist(&self) -> std::io::Result<()> {
+        if let Some(parent) = self.path.parent() {
+            tokio::fs::create_dir_all(parent).await?;
+        }
+        let snap = self.inner.read().await;
+        let body = serde_json::to_string_pretty(&*snap).map_err(std::io::Error::other)?;
+        tokio::fs::write(&self.path, body).await
+    }
+}

crates/pawscope-server/src/labels.rs

@@ -9,6 +9,7 @@ use tokio::sync::broadcast;
 pub mod api;
 pub mod assets;
 pub mod cache;
+pub mod labels;
 pub mod multi;
 pub mod skills;
 pub mod sse;
@@ -21,14 +22,17 @@ pub struct AppState {
     pub adapter: Arc<dyn AgentAdapter>,
     pub events: broadcast::Sender<pawscope_core::SessionEvent>,
     pub detail_cache: cache::DetailCache,
+    pub labels: labels::LabelStore,
 }
 
 pub fn build_app(adapter: Arc<dyn AgentAdapter>) -> (Router, AppState) {
     let (tx, _) = broadcast::channel(256);
+    let labels = futures::executor::block_on(labels::LabelStore::load());
     let state = AppState {
         adapter,
         events: tx,
         detail_cache: cache::DetailCache::new(),
+        labels,
     };
     let router = Router::new()
         .route("/api/sessions", get(api::list_sessions))
@@ -40,6 +44,8 @@ pub fn build_app(adapter: Arc<dyn AgentAdapter>) -> (Router, AppState) {
         .route("/api/prompts/search", get(api::prompts_search))
         .route("/api/tools/trend", get(api::tools_trend))
         .route("/api/tools/bucket", get(api::tools_bucket))
+        .route("/api/labels", get(api::list_labels))
+        .route("/api/labels/{id}", post(api::set_label))
         .route("/api/skills", get(skills::list_skills))
         .route("/api/skills/content", get(skills::skill_content))
         .route("/api/skills/usage", get(skills::skill_usage))

crates/pawscope-server/src/lib.rs

@@ -1,6 +1,6 @@
 import { useEffect, useState } from 'react';
 import './styles.css';
-import { fetchSessions, fetchDetail, connectWs } from './api';
+import { fetchSessions, fetchDetail, connectWs, fetchLabels, setLabel as apiSetLabel, type LabelMap } from './api';
 import { SessionList } from './components/SessionList';
 import { SessionDetail } from './components/SessionDetail';
 import { OverviewPanel } from './components/OverviewPanel';
@@ -23,6 +23,20 @@ export default function App() {
   const [realmPage, setRealmPage] = useState<string | null>(null);
   const [pendingSkill, setPendingSkill] = useState<{ name: string; n: number } | null>(null);
   const [pendingCategory, setPendingCategory] = useState<{ name: string; n: number } | null>(null);
+  const [labels, setLabels] = useState<LabelMap>({});
+
+  useEffect(() => {
+    fetchLabels().then(setLabels).catch(() => setLabels({}));
+  }, []);
+
+  const updateLabel = (id: string, label: { starred: boolean; tags: string[] }) => {
+    setLabels((prev) => ({ ...prev, [id]: label }));
+    apiSetLabel(id, label).catch(() => {});
+  };
+  const toggleStar = (id: string) => {
+    const cur = labels[id] ?? { starred: false, tags: [] };
+    updateLabel(id, { ...cur, starred: !cur.starred });
+  };
 
   useEffect(() => {
     fetchSessions().then(setSessions);
@@ -120,6 +134,8 @@ export default function App() {
           selected={selected}
           realmFilter={realmFilter}
           onClearRealmFilter={() => setRealmFilter(null)}
+          labels={labels}
+          onToggleStar={toggleStar}
         />
       </div>
       {view === 'overview' ? (
@@ -165,6 +181,8 @@ export default function App() {
             setPendingSkill(p => ({ name, n: (p?.n ?? 0) + 1 }));
             setView('skills');
           }}
+          label={selected ? labels[selected] : undefined}
+          onSetLabel={selected ? (lbl) => updateLabel(selected, lbl) : undefined}
         />
       )}
     </div>

web/src/App.tsx

@@ -185,3 +185,24 @@ export async function searchPrompts(
   if (!r.ok) throw new Error(`prompts search ${r.status}`);
   return r.json();
 }
+
+export interface Label {
+  starred: boolean;
+  tags: string[];
+}
+export type LabelMap = Record<string, Label>;
+
+export async function fetchLabels(): Promise<LabelMap> {
+  const r = await fetch('/api/labels');
+  if (!r.ok) return {};
+  return r.json();
+}
+export async function setLabel(id: string, label: Label): Promise<Label> {
+  const r = await fetch(`/api/labels/${encodeURIComponent(id)}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(label),
+  });
+  if (!r.ok) throw new Error(`set label ${r.status}`);
+  return r.json();
+}

web/src/api.ts

@@ -36,7 +36,13 @@ type Detail = {
   tool_calls?: { name: string; timestamp: string }[];
 };
 
-type Props = { meta: Meta | undefined; detail: Detail | null; onOpenSkill?: (name: string) => void };
+type Props = {
+  meta: Meta | undefined;
+  detail: Detail | null;
+  onOpenSkill?: (name: string) => void;
+  label?: { starred: boolean; tags: string[] };
+  onSetLabel?: (label: { starred: boolean; tags: string[] }) => void;
+};
 
 function timeAgo(iso?: string | null): string {
   if (!iso) return '—';
@@ -149,7 +155,7 @@ function PromptRow({
   );
 }
 
-export function SessionDetail({ meta, detail, onOpenSkill }: Props) {
+export function SessionDetail({ meta, detail, onOpenSkill, label, onSetLabel }: Props) {
   const { t, lang } = useT();
   const tools = useMemo(() => {
     if (!detail?.tools_used) return [];
@@ -191,6 +197,15 @@ export function SessionDetail({ meta, detail, onOpenSkill }: Props) {
               {meta.pid && (
                 <span className="text-[11px] text-slate-500 font-mono">pid {meta.pid}</span>
               )}
+              {onSetLabel && (
+                <button
+                  onClick={() => onSetLabel({ starred: !(label?.starred ?? false), tags: label?.tags ?? [] })}
+                  title={label?.starred ? 'Unstar' : 'Star'}
+                  className={`ml-1 text-base leading-none ${label?.starred ? 'text-amber-300' : 'text-slate-600 hover:text-slate-400'}`}
+                >
+                  {label?.starred ? '★' : '☆'}
+                </button>
+              )}
             </div>
             <h1 className="text-2xl font-semibold text-slate-100 truncate">
               {meta.summary || <span className="text-slate-500 italic">{t('misc.no_summary')}</span>}
@@ -228,6 +243,35 @@ export function SessionDetail({ meta, detail, onOpenSkill }: Props) {
         </dl>
       </header>
 
+      {onSetLabel && (
+        <div className="px-8 py-2 border-b border-slate-800 bg-slate-900/20 flex items-center gap-2 flex-wrap">
+          <span className="text-[10px] uppercase tracking-wider text-slate-500">tags</span>
+          {(label?.tags ?? []).map((tg) => (
+            <span key={tg} className="inline-flex items-center gap-1 px-2 py-0.5 rounded bg-violet-500/15 text-violet-200 text-[11px]">
+              #{tg}
+              <button
+                onClick={() => onSetLabel({ starred: label?.starred ?? false, tags: (label?.tags ?? []).filter((x) => x !== tg) })}
+                className="text-violet-400 hover:text-violet-100"
+              >×</button>
+            </span>
+          ))}
+          <input
+            type="text"
+            placeholder="+ tag"
+            onKeyDown={(e) => {
+              if (e.key === 'Enter') {
+                const v = (e.target as HTMLInputElement).value.trim();
+                if (v && !(label?.tags ?? []).includes(v)) {
+                  onSetLabel({ starred: label?.starred ?? false, tags: [...(label?.tags ?? []), v] });
+                }
+                (e.target as HTMLInputElement).value = '';
+              }
+            }}
+            className="px-2 py-0.5 text-[11px] bg-slate-900 border border-slate-800 rounded text-slate-200 placeholder:text-slate-600 focus:outline-none focus:border-slate-600 w-20"
+          />
+        </div>
+      )}
+
       {!detail ? (
         <div className="p-8 text-sm text-slate-500">{t('detail.loading')}</div>
       ) : (