update agents skill design

src/components/ai-assistant/history.js

@@ -31,6 +31,42 @@ const MAX_RECORDS = 100;
 
 const DAY = 24 * 60 * 60 * 1000;
 
+/**
+ * The shape of a stored record.
+ *
+ * Bumped when a record gains fields, so a reader can tell an old record from a
+ * new one instead of guessing from which keys happen to be present.
+ */
+const SCHEMA = 2;
+
+/**
+ * An older record, brought up to date on the way out.
+ *
+ * A conversation held before agents existed is still a conversation somebody
+ * had. It gets the new fields at their empty values and keeps everything it
+ * already had — in particular `messages` is passed through untouched, so
+ * nothing a reader wrote is rewritten by a schema change.
+ *
+ * Migrating on read rather than rewriting the store means a browser that never
+ * opens History again still loses nothing, and there is no migration pass that
+ * can fail halfway.
+ */
+function migrate(record) {
+  if (record.schema === SCHEMA) return record;
+  return {
+    ...record,
+    schema: SCHEMA,
+    /* Absent, not unknown: these conversations genuinely had no agent, no
+       recorded skills and no feedback. */
+    agentId: record.agentId ?? null,
+    pageContext: record.pageContext ?? null,
+    skillsUsed: Array.isArray(record.skillsUsed) ? record.skillsUsed : [],
+    toolsUsed: Array.isArray(record.toolsUsed) ? record.toolsUsed : [],
+    knowledgeUsed: Array.isArray(record.knowledgeUsed) ? record.knowledgeUsed : [],
+    feedback: record.feedback ?? null,
+  };
+}
+
 /** Every archived conversation, newest first. Never throws. */
 export function readHistory() {
   try {
@@ -42,6 +78,7 @@ export function readHistory() {
     return list
       .filter((r) => r && r.id && Array.isArray(r.messages) && r.messages.length)
       .filter((r) => new Date(r.updatedAt || 0).getTime() >= cutoff)
+      .map(migrate)
       .sort((a, b) => new Date(b.updatedAt || 0).getTime() - new Date(a.updatedAt || 0).getTime());
   } catch {
     /* Corrupt or unavailable storage is an empty history, not an error the
@@ -64,13 +101,39 @@ function titleFor(messages) {
  * Matched on `id`, so a thread being added to updates in place rather than
  * appearing once per turn.
  */
-export function saveConversation({ id, contextId, page, messages }) {
+export function saveConversation({
+  id, contextId, page, messages,
+  /**
+   * Who answered, where, and what it actually used.
+   *
+   * Recorded from what ran rather than from what was available: `skillsUsed`
+   * is the skill that answered a turn, not every skill the page offered. A
+   * record of what *could* have happened would make the insight figures
+   * describe the registry instead of the conversation.
+   */
+  agentId = null, pageContext = null,
+  skillsUsed = [], toolsUsed = [], knowledgeUsed = [],
+}) {
   if (!id || !Array.isArray(messages) || !messages.length) return readHistory();
 
+  /* Feedback belongs to the conversation, not to the turn that triggered a
+     save, so an existing rating survives the thread growing. */
+  const existing = readHistory().find((r) => r.id === id) || null;
+
   const record = {
+    schema: SCHEMA,
     id,
     contextId,
     page: page || '',
+    agentId,
+    /* The *reduced* envelope — where the question was asked, never a copy of
+       what was on screen. Storing selections and computed figures would write
+       the dataset into localStorage a turn at a time. */
+    pageContext,
+    skillsUsed: [...new Set(skillsUsed.filter(Boolean))],
+    toolsUsed: [...new Set(toolsUsed.filter(Boolean))],
+    knowledgeUsed: [...new Set(knowledgeUsed.filter(Boolean))],
+    feedback: existing?.feedback ?? null,
     title: titleFor(messages),
     turns: messages.filter((m) => m.role === 'user').length,
     updatedAt: new Date().toISOString(),
@@ -95,6 +158,41 @@ export function saveConversation({ id, contextId, page, messages }) {
   return next;
 }
 
+/**
+ * Records how a conversation was rated.
+ *
+ * Updates in place and never appends: rating a thread twice is a correction,
+ * not two opinions. Returns the refreshed list so a caller re-renders from one
+ * read rather than two.
+ */
+export function recordFeedback(id, feedback) {
+  const list = readHistory();
+  const at = list.findIndex((r) => r.id === id);
+  if (at === -1) return list;
+
+  const next = [...list];
+  next[at] = {
+    ...next[at],
+    feedback: feedback
+      ? {
+        rating: feedback.rating === 'up' ? 'up' : 'down',
+        note: String(feedback.note || '').trim() || null,
+        at: new Date().toISOString(),
+      }
+      /* Clearing is a real action — someone un-rating a thread should leave no
+         rating behind rather than a neutral one. */
+      : null,
+  };
+
+  try {
+    localStorage.setItem(KEY, JSON.stringify(next));
+  } catch {
+    /* The rating stays in memory for this session. */
+  }
+
+  return next;
+}
+
 /** Forgets one conversation. */
 export function removeConversation(id) {
   const next = readHistory().filter((r) => r.id !== id);