update ui design for all pages

src/components/ai-assistant/useAssistant.js

@@ -5,8 +5,14 @@ import {
   useApplications, useCourses, useInterviews, useJobPostings, useStaff,
   useUserActivity, useWorkerProfile, useWorkerProfiles,
 } from '@/lib/krowHooks';
+import { skillsForContext } from '@/lib/skills/registry';
+import {
+  advancePositionFlow, createdFollowUp, positionCreatedReply, positionFailedReply,
+} from '@/lib/skills/positionFlow';
 import { buildFacts } from './insights';
 import { createAssistantProvider } from './provider';
+import { resolveIntent } from './routing';
+import { toSnapshots } from './blocks';
 
 /** One provider instance for the app's lifetime. */
 const provider = createAssistantProvider();
@@ -32,9 +38,17 @@ export function useAssistantFacts() {
   // rather than manufacturing a record as a side effect of opening a panel.
   const { data: profile = null } = useWorkerProfile({ enabled: false });
 
+  /* The signed-in account, from the shared `['user']` cache the header and the
+     Profile page already read. */
+  const { data: user = null } = useQuery({
+    queryKey: ['user'],
+    queryFn: () => base44.auth.me().catch(() => null),
+    staleTime: Infinity,
+  });
+
   return React.useMemo(
-    () => buildFacts({ applications, postings, interviews, staff, profiles, activity, courses, profile }),
-    [applications, postings, interviews, staff, profiles, activity, courses, profile]
+    () => buildFacts({ applications, postings, interviews, staff, profiles, activity, courses, profile, user }),
+    [applications, postings, interviews, staff, profiles, activity, courses, profile, user]
   );
 }
 
@@ -53,6 +67,23 @@ export function useCurrentUserName() {
   return data?.full_name || '';
 }
 
+/**
+ * Streams a locally built document through the same snapshot pipeline the
+ * provider uses, so a routing reply arrives exactly like any other answer
+ * rather than appearing instantly and reading as a different system.
+ */
+async function streamDocument({ document, signal, onFrame, onDone }) {
+  const snapshots = toSnapshots(document);
+  let latest = [];
+  for (const snapshot of snapshots) {
+    if (signal?.aborted) break;
+    latest = snapshot;
+    onFrame(snapshot);
+    await new Promise((resolve) => setTimeout(resolve, 26));
+  }
+  if (latest.length) onDone(latest);
+}
+
 /**
  * Conversation state for one page context.
  *
@@ -60,15 +91,39 @@ export function useCurrentUserName() {
  * kept per context in sessionStorage so navigating away from Candidates and back
  * does not silently discard the conversation — while a stale thread from last
  * week is still not resurrected.
+ *
+ * `onNavigate` is called when a question belongs to another Admin page. Both
+ * entry points — a suggestion chip and a typed question — go through `send`, so
+ * routing applies to both without either knowing it exists.
  */
-export function useConversation({ contextId, facts }) {
+export function useConversation({
+  contextId, facts, onNavigate, onAction, onCreatePosition, disabledSkills = [], customSkills = [],
+  roles = [], skillCategories = [], courses = [],
+}) {
   const storageKey = `krow_assistant:${contextId}`;
+  const flowKey = `${storageKey}:flow`;
 
   const [messages, setMessages] = React.useState([]);
   const [pending, setPending] = React.useState(null); // { blocks, thinking }
   const [error, setError] = React.useState(null);
   const abortRef = React.useRef(null);
 
+  /* A guided skill in progress — which question it is on and what it has
+     collected. Kept beside the thread rather than inside it, and persisted for
+     the same reason the thread is: leaving Positions and coming back should not
+     silently abandon a position half-described. */
+  const flowRef = React.useRef(null);
+
+  const setFlow = React.useCallback((flow) => {
+    flowRef.current = flow || null;
+    try {
+      if (flow) sessionStorage.setItem(flowKey, JSON.stringify(flow));
+      else sessionStorage.removeItem(flowKey);
+    } catch {
+      // The flow stays in memory only.
+    }
+  }, [flowKey]);
+
   /* Load the stored thread, and reload when the context changes. */
   React.useEffect(() => {
     try {
@@ -77,9 +132,15 @@ export function useConversation({ contextId, facts }) {
     } catch {
       setMessages([]);
     }
+    try {
+      const raw = sessionStorage.getItem(flowKey);
+      flowRef.current = raw ? JSON.parse(raw) : null;
+    } catch {
+      flowRef.current = null;
+    }
     setPending(null);
     setError(null);
-  }, [storageKey]);
+  }, [storageKey, flowKey]);
 
   const persist = React.useCallback((next) => {
     setMessages(next);
@@ -112,6 +173,104 @@ export function useConversation({ contextId, facts }) {
     setError(null);
     setPending({ blocks: [], thinking: true });
 
+    /**
+     * A guided skill in progress takes the message first: while Owliver is
+     * asking the questions, "Chennai" is an answer rather than a question about
+     * the page. The skill has to still be enabled — switching it off in Settings
+     * ends the flow rather than letting it run on without permission.
+     */
+    let intent = null;
+    if (flowRef.current) {
+      const skill = skillsForContext(contextId, disabledSkills, customSkills)
+        .find((s) => s.id === flowRef.current.skillId);
+
+      if (!skill) setFlow(null);
+      else {
+        intent = {
+          kind: 'flow',
+          skill,
+          ...advancePositionFlow({ flow: flowRef.current, answer: text, skill, roles }),
+        };
+      }
+    }
+
+    /* A chip is this page's own capability by construction, so it never routes
+       away. A typed question might belong somewhere else entirely. */
+    if (!intent) {
+      intent = capability
+        ? { kind: 'answer' }
+        : resolveIntent({
+            question: text, contextId, disabledSkills, customSkills, roles, skillCategories, courses,
+          });
+    }
+
+    /**
+     * The one step that writes. It happens before the reply rather than after,
+     * because the reply is the outcome — "Position created successfully" has to
+     * be true when it is said.
+     */
+    if (intent.kind === 'flow' && intent.create) {
+      let created = null;
+      try {
+        created = await onCreatePosition?.(intent.create.draft, intent.skill);
+      } catch {
+        created = null;
+      }
+
+      if (created?.id) {
+        intent = {
+          ...intent, flow: null, doc: positionCreatedReply(created), followUp: createdFollowUp(created),
+        };
+      } else {
+        /* Keep the answers: the summary is still there to try again from. */
+        intent = {
+          ...intent,
+          flow: { ...intent.flow, stage: 'review' },
+          doc: positionFailedReply(),
+          followUp: [
+            { label: 'Create position', prompt: 'Create position' },
+            { label: 'Change details', prompt: 'Change details' },
+          ],
+        };
+      }
+    }
+
+    /* A skill that collects its input in the chat carries the state of that
+       collection on every turn — including the turn that starts it. */
+    if ('flow' in intent) setFlow(intent.flow);
+
+    if (intent.kind !== 'answer') {
+      try {
+        await streamDocument({
+          document: intent.doc,
+          signal: controller.signal,
+          onFrame: (blocks) => setPending({ blocks, thinking: false }),
+          onDone: (blocks) => {
+            const next = [
+              ...messagesRef.current,
+              { role: 'assistant', blocks, followUp: intent.followUp },
+            ];
+            messagesRef.current = next;
+            persist(next);
+          },
+        });
+      } finally {
+        setPending(null);
+        abortRef.current = null;
+      }
+
+      /* Navigate after the reply is on screen, so the user reads why they moved.
+         The panel re-resolves its context from the new route, which is what
+         makes the next question answer from the page they land on. */
+      if (controller.signal.aborted) return;
+
+      if (intent.kind === 'navigate') onNavigate?.(intent.destination);
+      /* A skill's action runs after its reply, for the same reason: the user
+         should read why the form opened before it opens. */
+      if (intent.kind === 'skill' && intent.action) onAction?.(intent.action, intent.skill);
+      return;
+    }
+
     try {
       let latest = [];
       for await (const snapshot of provider.stream({
@@ -141,7 +300,8 @@ export function useConversation({ contextId, facts }) {
       setPending(null);
       abortRef.current = null;
     }
-  }, [contextId, facts, persist]);
+  }, [contextId, facts, persist, onNavigate, onAction, onCreatePosition, setFlow, disabledSkills,
+      customSkills, roles, skillCategories, courses]);
 
   const stop = React.useCallback(() => abortRef.current?.abort(), []);
 
@@ -151,12 +311,15 @@ export function useConversation({ contextId, facts }) {
     setMessages([]);
     setPending(null);
     setError(null);
+    /* A new conversation abandons a half-collected position too — the questions
+       it was answering are no longer on screen. */
+    setFlow(null);
     try {
       sessionStorage.removeItem(storageKey);
     } catch {
       // Ignore.
     }
-  }, [storageKey]);
+  }, [storageKey, setFlow]);
 
   return {
     messages,