@abot-ai/runtime 1.8.1 → 1.9.0

package/dist/src/web-ui/app/controllers/automation-run-history.js

@@ -0,0 +1,159 @@
+const PAGE_SIZE = 50;
+const emptyFilters = () => ({ status: "", from: "", to: "" });
+
+function localDay(value) {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(value)) return null;
+  const [year, month, day] = value.split("-").map(Number);
+  const date = new Date(0);
+  date.setFullYear(year, month - 1, day);
+  date.setHours(0, 0, 0, 0);
+  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day)
+    return null;
+  return date;
+}
+
+function historyQuery(filters) {
+  const query = { limit: PAGE_SIZE };
+  if (filters.status) query.status = filters.status;
+  const from = filters.from ? localDay(filters.from) : null;
+  const to = filters.to ? localDay(filters.to) : null;
+  if (filters.from && !from) throw new Error("Choose a valid start date.");
+  if (filters.to && !to) throw new Error("Choose a valid end date.");
+  if (to) to.setDate(to.getDate() + 1);
+  if (from && to && from >= to) throw new Error("The end date must be on or after the start date.");
+  if (from) query.from = from.toISOString();
+  if (to) query.to = to.toISOString();
+  return query;
+}
+
+export function automationRunPage(response) {
+  return {
+    runs: Array.isArray(response?.runs) ? response.runs : [],
+    runsNextCursor: typeof response?.nextCursor === "string" ? response.nextCursor : null,
+  };
+}
+
+function appendRunPage(runs, page) {
+  const entries = new Map(runs.map((run) => [run.id, run]));
+  for (const run of page) entries.set(run.id, run);
+  return [...entries.values()];
+}
+
+/** History belongs to an automation/environment, independently of its selected report. */
+export function createAutomationRunHistory({ state, client, getEnvironmentId, publish, errorLabel }) {
+  let revision = 0;
+  let loaded = false;
+  let pages = 0;
+  let failedRead = null;
+  let pendingFilters = null;
+
+  function resetScope() {
+    revision += 1;
+    loaded = false;
+    pages = 0;
+    failedRead = null;
+    pendingFilters = null;
+    Object.assign(state, { runs: [], runsNextCursor: null, runsLoading: false,
+      runsError: "", runsFilterError: "", runsFilters: emptyFilters() });
+  }
+
+  function captureScope() {
+    const environmentId = getEnvironmentId(), automationId = state.selectedAutomationId;
+    const capturedRevision = revision;
+    return { environmentId, automationId, isCurrent: () => capturedRevision === revision &&
+      environmentId === getEnvironmentId() && automationId === state.selectedAutomationId };
+  }
+
+  function canRefreshFirstPage(refresh) {
+    if (state.runsLoading) return false;
+    if (failedRead) return false;
+    if (!loaded) return true;
+    return refresh && pages < 2;
+  }
+
+  function captureRead({ refresh = false } = {}) {
+    const scope = captureScope();
+    const query = scope.automationId && canRefreshFirstPage(refresh) ? historyQuery(state.runsFilters) : null;
+    return { query, isCurrent: scope.isCurrent, accept(projection) {
+      if (!query || !scope.isCurrent()) return;
+      state.runs = projection.runs;
+      state.runsNextCursor = projection.runsNextCursor;
+      loaded = true;
+      pages = 1;
+    } };
+  }
+
+  async function readPage(filters, query, kind, isCurrent = () => true) {
+    revision += 1;
+    const scope = captureScope();
+    const canApplyHistoryRead = () => scope.isCurrent() && isCurrent();
+    failedRead = null;
+    pendingFilters = filters;
+    state.runsLoading = true;
+    state.runsError = "";
+    state.runsFilterError = "";
+    publish();
+    try {
+      const response = await client.listAutomationRuns(scope.automationId, scope.environmentId, query);
+      if (!canApplyHistoryRead()) return false;
+      const page = automationRunPage(response);
+      state.runs = kind === "more" ? appendRunPage(state.runs, page.runs) : page.runs;
+      state.runsNextCursor = page.runsNextCursor;
+      state.runsFilters = filters;
+      loaded = true;
+      pages = kind === "more" ? pages + 1 : 1;
+      return true;
+    } catch (error) {
+      if (!canApplyHistoryRead()) return false;
+      if (kind === "filter") {
+        state.runsFilterError = errorLabel(error);
+        return false;
+      }
+      state.runsError = errorLabel(error);
+      failedRead = { filters, query, kind };
+      return false;
+    } finally {
+      if (scope.isCurrent()) {
+        pendingFilters = null;
+        state.runsLoading = false;
+        publish();
+      }
+    }
+  }
+
+  async function setRunFilters(input) {
+    if (!state.selectedAutomationId) return false;
+    const filters = { status: input?.status || "", from: input?.from || "", to: input?.to || "" };
+    let query;
+    try { query = historyQuery(filters); }
+    catch (error) {
+      state.runsFilterError = errorLabel(error);
+      publish();
+      return false;
+    }
+    return readPage(filters, query, "filter");
+  }
+
+  function loadMoreRuns() {
+    if (!state.selectedAutomationId || !state.runsNextCursor || state.runsLoading) return false;
+    return readPage(state.runsFilters,
+      { ...historyQuery(state.runsFilters), cursor: state.runsNextCursor }, "more");
+  }
+
+  function resetRunHistory({ isCurrent = () => true, supersede = false } = {}) {
+    if (!state.selectedAutomationId || !isCurrent()) return false;
+    if (state.runsLoading && !supersede) return false;
+    const filters = pendingFilters || state.runsFilters;
+    return readPage(filters, historyQuery(filters), "reset", isCurrent);
+  }
+
+  function retryRunHistory() {
+    if (!failedRead || state.runsLoading) return false;
+    const { filters, query, kind } = failedRead;
+    return readPage(filters, query, kind);
+  }
+
+  resetScope();
+  return { resetScope, captureRead, revision: () => revision,
+    setRunFilters, loadMoreRuns, resetRunHistory, retryRunHistory };
+}

package/dist/src/web-ui/app/controllers/automations-controller.js

@@ -6,6 +6,7 @@ import { createAutomationDraftActions } from "./automation-draft-actions.js";
 import { createAutomationRunActions } from "./automation-run-actions.js";
 import { createAutomationViewCapture } from "./automation-view-scope.js";
 import { createAutomationManagementActions } from "./automation-management-actions.js";
+import { createAutomationRunHistory } from "./automation-run-history.js";
 import {
   automationProjectionChanged, readAutomationBackgroundProjection,
   readAutomationList, readAutomationSelection, validationResult,
@@ -31,7 +32,7 @@ export function createAutomationsController({
   isEditingDirty = () => false,
 }) {
   const state = {
-    automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "",
+    automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "", lastViewedRunId: "",
     draft: null, publishedDefinition: null, grant: null, validation: null, validationVisible: false,
     catalog: null, templateCatalog: null, templateCatalogError: "", runs: [], run: null,
     loading: false, mutation: "", error: "", feedback: "",
@@ -50,6 +51,8 @@ export function createAutomationsController({
   const snapshot = () => ({ ...state, draftUndo: draftActions?.undoState() || null,
     runStartPending: runActions?.isStartingRun() || false });
   const publish = () => render(snapshot());
+  const runHistory = createAutomationRunHistory({ state, client, getEnvironmentId, publish, errorLabel });
+  const { setRunFilters, loadMoreRuns, resetRunHistory, retryRunHistory } = runHistory;
   const currentEnvironment = (environmentId) => environmentId === getEnvironmentId();
   const captureView = createAutomationViewCapture({ state, getEnvironmentId,
     getNavigationRevision: () => navigationRevision, getNavigationRequestRevision: () => navigationRequestRevision,
@@ -61,7 +64,8 @@ export function createAutomationsController({
     currentEnvironment, captureView });
   const { mutateDraft, saveDefinition, saveNode, undoDraftMove, restorePublishedDraft } = draftActions;
   runActions = createAutomationRunActions({ client, mutation, publish,
-    loadSelected, openRun, captureView });
+    loadSelected, openRun, captureView,
+    refreshRunHistory: (isCurrent) => runHistory.resetRunHistory({ isCurrent, supersede: true }) });
   const { startRun, stopRun, rerun } = runActions;
   const { create, deleteDraft, publishDefinition, setActive, changeArchiveState, setPermission } =
     createAutomationManagementActions({ state, client, mutation, captureView,
@@ -86,14 +90,16 @@ export function createAutomationsController({
     state.stepEvidenceLoading = false;
     state.stepEvidenceError = "";
     if (automationChanged) {
+      state.lastViewedRunId = "";
       state.draft = null;
       state.publishedDefinition = null;
       state.grant = null;
       state.validation = null;
       state.validationVisible = false;
       state.catalog = null;
-      state.runs = [];
+      runHistory.resetScope();
     }
+    if (runId) state.lastViewedRunId = runId;
     navigationRevision += 1;
     onNavigationChange();
   }
@@ -123,19 +129,23 @@ export function createAutomationsController({
     }
   }
 
-  async function loadSelected(automationId, runId = "", isCurrent = () => true) {
+  async function loadSelected(automationId, runId = "", isCurrent = () => true, refreshRuns = false) {
     if (!isCurrent()) return false;
     const environmentId = getEnvironmentId();
     const revision = ++readRevision;
+    const historyRead = runHistory.captureRead({ refresh: refreshRuns });
     state.loading = true;
     state.error = "";
     publish();
     try {
-      const projection = await readAutomationSelection(client, automationId, runId, environmentId);
+      const projection = await readAutomationSelection(client, automationId, runId, environmentId,
+        { runsQuery: historyRead.query });
       if (!isCurrent()) return false;
       if (revision !== readRevision || !currentEnvironment(environmentId)) return false;
       if (state.selectedAutomationId !== automationId) return false;
-      Object.assign(state, projection);
+      const { runs, runsNextCursor, ...selection } = projection;
+      Object.assign(state, selection);
+      historyRead.accept({ runs, runsNextCursor });
       const selectedNodeId = selectedAutomationRunStepId(state.run, state.selectedNodeId);
       const initialStepSelected = selectedNodeId !== state.selectedNodeId;
       state.selectedNodeId = selectedNodeId;
@@ -181,7 +191,7 @@ export function createAutomationsController({
     const loadedList = await loadList(isCurrent);
     if (!loadedList || !isCurrent()) return false;
     if (!selected) return true;
-    const selectedLoaded = await loadSelected(selected, runId, isCurrent);
+    const selectedLoaded = await loadSelected(selected, runId, isCurrent, true);
     if (!selectedLoaded || !isCurrent()) return false;
     if (selectedLoaded && runId && state.selectedNodeId)
       await loadStepEvidence(runId, state.selectedNodeId, stepEvidenceFull, isCurrent);
@@ -193,24 +203,29 @@ export function createAutomationsController({
         state.mutation || isEditingDirty()) return false;
     if (!currentEnvironment(identity.environmentId) || identity.readRevision !== readRevision ||
         identity.navigationRevision !== navigationRevision || identity.mutationRevision !== mutationRevision ||
-        identity.evidenceRevision !== evidenceReadRevision) return false;
+        identity.evidenceRevision !== evidenceReadRevision ||
+        identity.historyRevision !== runHistory.revision()) return false;
     return state.selectedAutomationId === identity.automationId &&
       state.selectedRunId === identity.runId && state.selectedNodeId === identity.nodeId;
   }
 
   async function backgroundRefresh() {
+    const historyRead = runHistory.captureRead({ refresh: true });
     const identity = {
       environmentId: getEnvironmentId(), automationId: state.selectedAutomationId,
       runId: state.selectedRunId, nodeId: state.selectedNodeId,
       readRevision, navigationRevision, mutationRevision,
       evidenceRevision: evidenceReadRevision, full: stepEvidenceFull,
+      runsQuery: historyRead.query, historyRevision: runHistory.revision(),
     };
     if (!backgroundIdentityMatches(identity)) return false;
     try {
       const projection = await readAutomationBackgroundProjection(client, identity);
       if (!backgroundIdentityMatches(identity)) return false;
       if (!automationProjectionChanged(state, projection)) return true;
-      Object.assign(state, projection);
+      const { runs, runsNextCursor, ...selection } = projection;
+      Object.assign(state, selection);
+      historyRead.accept({ runs, runsNextCursor });
       publish();
       return true;
     } catch {
@@ -339,9 +354,10 @@ export function createAutomationsController({
     draftActions.clearUndo();
     readRevision += 1;
     loaded = false;
+    runHistory.resetScope();
     stepEvidenceFull = false;
     Object.assign(state, {
-      automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "",
+      automations: [], selectedAutomationId: "", selectedRunId: "", selectedNodeId: "", lastViewedRunId: "",
       draft: null, publishedDefinition: null, grant: null, validation: null, validationVisible: false,
       catalog: null, templateCatalog: null, templateCatalogError: "", runs: [], run: null,
       loading: false, error: "", feedback: "",
@@ -369,7 +385,7 @@ export function createAutomationsController({
     createTemplate: (templateId) => create(templateId), deleteDraft, mutateDraft, saveDefinition,
     saveNode, saveAgent, validate, publishDefinition, setActive, undoDraftMove, restorePublishedDraft,
     archive: () => changeArchiveState(true), restore: () => changeArchiveState(false),
-    setPermission, openRun,
+    setPermission, openRun, setRunFilters, loadMoreRuns, resetRunHistory, retryRunHistory,
     startRun, stopRun, rerun, environmentChanged, setWorkspaceActive, handleRealtime,
     showFullStepOutput() {
       if (!state.selectedRunId || !state.selectedNodeId) return false;

package/dist/src/web-ui/app/controllers/environment-workspace-preparation.js

@@ -1,16 +1,20 @@
 import { environmentChangeWasDeclined } from "./environment-transition.js";
 
-/** Discard configuration and schedule drafts only after both preparations remain current. */
-export function prepareEnvironmentWorkspaceChanges(schedules, configuration) {
+/** Discard workspace drafts only after every preparation remains current. */
+export function prepareEnvironmentWorkspaceChanges(schedules, configuration, skills) {
   const schedule = schedules.prepareEnvironmentChange();
   if (environmentChangeWasDeclined(schedule)) return null;
   const config = configuration.prepareDiscardChanges("change environment");
   if (environmentChangeWasDeclined(config)) return null;
+  const skill = skills ? skills.prepareEnvironmentChange() : true;
+  if (environmentChangeWasDeclined(skill)) return null;
   const commit = () => {
+    if (typeof skill === "function") skill();
     if (typeof schedule === "function") schedule();
     if (typeof config === "function") config();
   };
   commit.canCommit = () => {
+    if (skill?.canCommit?.() === false) return false;
     if (schedule?.canCommit?.() === false) return false;
     return config?.canCommit?.() !== false;
   };

package/dist/src/web-ui/app/controllers/realtime-event-controller.js

@@ -16,6 +16,14 @@ import { normalizeRealtimeMessage } from "../lib/realtime-message.js";
 import { reduceTaskProgress } from "../lib/task-progress.js";
 import { projectWebSourceEvent } from "../lib/web-source-event.js";
 import { projectToolActivityEvent } from "../lib/tool-activity-event.js";
+import {
+  hasRecordedRoleDelegation,
+  projectRoleDelegationEvent,
+} from "../lib/role-delegation-event.js";
+import {
+  hasRecordedRoleReturn,
+  projectRoleReturnEvent,
+} from "../lib/role-return-event.js";
 import {
   contextEvidenceScope,
   contextEvidenceOrder,
@@ -47,10 +55,14 @@ function canMergeUnsequencedActivity(
   eventSequence,
   webSources,
   toolActivity,
+  roleDelegation,
+  roleReturn,
 ) {
   if (eventSequence !== undefined) return false;
   if (webSources || previous?.webSources) return false;
   if (toolActivity || previous?.toolActivity) return false;
+  if (roleDelegation || previous?.roleDelegation) return false;
+  if (roleReturn || previous?.roleReturn) return false;
   if (!previous?.key || previous.key !== key) return false;
   return !hasOriginalEventSequence(previous.eventSequence);
 }
@@ -158,7 +170,12 @@ export function createRealtimeEventController({
       renderContextWindow();
       renderActivityStatus();
     }
-    if (hasRecordedOriginalEvent(state.events, requestId, eventSequence)) {
+    const roleDelegation = projectRoleDelegationEvent(message);
+    const roleReturn = projectRoleReturnEvent(message);
+    let alreadyRecorded = hasRecordedOriginalEvent(state.events, requestId, eventSequence);
+    if (roleDelegation) alreadyRecorded = hasRecordedRoleDelegation(state.events, roleDelegation);
+    if (roleReturn) alreadyRecorded = hasRecordedRoleReturn(state.events, roleReturn);
+    if (alreadyRecorded) {
       trackSeq(message);
       return;
     }
@@ -188,6 +205,8 @@ export function createRealtimeEventController({
         eventSequence,
         webSources,
         toolActivity,
+        roleDelegation,
+        roleReturn,
       )
     ) {
       lastEvent.count = (lastEvent.count || 1) + 1;
@@ -224,6 +243,8 @@ export function createRealtimeEventController({
         ),
         ...(webSources ? { webSources } : {}),
         ...(toolActivity ? { toolActivity } : {}),
+        ...(roleDelegation ? { roleDelegation } : {}),
+        ...(roleReturn ? { roleReturn } : {}),
         payload: {
           plan: message.plan,
           item: message.item,

package/dist/src/web-ui/app/controllers/runtime-selection-controller.js

@@ -157,7 +157,13 @@ export function createRuntimeSelectionController({
     renderAgentMode();
   }
 
+  function hasModelCatalogFromAnotherEnvironment() {
+    if (modelCatalogEnvironmentId === null) return false;
+    return modelCatalogEnvironmentId !== selectedEnvironmentId();
+  }
+
   function rememberModelSelection() {
+    if (hasModelCatalogFromAnotherEnvironment()) return;
     const profileId = textOf(dom.modelSelect.value);
     if (!profileId) return;
     state.lastModelByEnvironment[selectedEnvironmentId()] = profileId;
@@ -176,7 +182,7 @@ export function createRuntimeSelectionController({
 
   const { renderAgentMode, loadAgentMode, setAgentMode } = createReasoningModeController({
     state, dom, client, selectedEnvironmentId,
-    selectedModelProfile: () => modelCatalogEnvironmentId !== null && modelCatalogEnvironmentId !== selectedEnvironmentId() ? null : selectedModelProfile(),
+    selectedModelProfile: () => hasModelCatalogFromAnotherEnvironment() ? null : selectedModelProfile(),
     reloadModels: onReasoningConfigurationApplied || loadModels, recordControlEvent,
   });
 

package/dist/src/web-ui/app/controllers/skills-controller.js

@@ -0,0 +1,237 @@
+/** Owns personal Skill drafts and environment-bound reads/mutations. */
+export function createSkillsController({ client, getEnvironmentId, render,
+  confirmDiscard = (message) => window.confirm(message) }) {
+  const state = { items: [], skill: null, draft: "", archived: false, creating: false, name: "", description: "",
+    loading: false, reading: false, mutation: "", error: "", message: "" };
+  let epoch = 0;
+  let listRead = 0;
+  let detailRead = 0;
+  let draftRevision = 0;
+  let active = false;
+  const snapshot = () => ({ ...state, items: [...state.items], dirty: isDirty() });
+  const publish = () => render(snapshot());
+  function isDirty() {
+    if (state.creating) return Boolean(state.name || state.description || state.draft);
+    return Boolean(state.skill && state.draft !== state.skill.content);
+  }
+  const capture = () => ({ epoch, environmentId: getEnvironmentId() });
+  function isCurrent(scope) {
+    if (scope.epoch !== epoch) return false;
+    return scope.environmentId === getEnvironmentId();
+  }
+  function clearEditor() {
+    detailRead += 1;
+    draftRevision += 1;
+    state.skill = null;
+    state.creating = false;
+    state.name = "";
+    state.description = "";
+    state.draft = "";
+    state.reading = false;
+  }
+  function canEdit() {
+    if (state.mutation || state.reading) return false;
+    if (state.creating) return true;
+    if (!state.skill || state.skill.archived) return false;
+    return state.skill.source === "personal";
+  }
+  function prepareLeave() {
+    if (state.mutation) return false;
+    if (!isDirty()) return true;
+    if (!confirmDiscard("Discard unsaved Skill changes?")) return false;
+    const revision = draftRevision;
+    const scope = capture();
+    const commit = () => {
+      if (!commit.canCommit()) return;
+      if (state.creating) clearEditor();
+      else { state.draft = state.skill.content; draftRevision += 1; }
+      publish();
+    };
+    commit.canCommit = () => isCurrent(scope) && revision === draftRevision;
+    return commit;
+  }
+  function acceptLeave() {
+    const prepared = prepareLeave();
+    if (prepared === false) return false;
+    if (typeof prepared === "function") prepared();
+    return true;
+  }
+  async function refresh() {
+    if (!client.supportsSkills()) return;
+    const scope = capture();
+    const read = ++listRead;
+    state.loading = true;
+    publish();
+    try {
+      const result = await client.listPersonalSkills(scope.environmentId);
+      if (!isCurrent(scope) || read !== listRead) return;
+      state.items = result.items.filter((item) => item.source === "personal");
+    } catch (error) {
+      if (!isCurrent(scope) || read !== listRead) return;
+      state.error = error.message || String(error);
+    } finally {
+      if (isCurrent(scope) && read === listRead) { state.loading = false; publish(); }
+    }
+  }
+  async function select(skillId) {
+    if (state.skill?.skillId === skillId) return true;
+    if (!acceptLeave()) return false;
+    if (!state.items.some((item) => item.skillId === skillId)) return false;
+    return loadSkill(skillId);
+  }
+  async function loadSkill(skillId) {
+    const scope = capture();
+    clearEditor();
+    const read = detailRead;
+    state.error = "";
+    state.message = "";
+    state.reading = true;
+    publish();
+    try {
+      const { skill } = await client.readPersonalSkill(skillId, scope.environmentId);
+      if (!isCurrent(scope) || read !== detailRead) return false;
+      if (skill.source !== "personal" || skill.skillId !== skillId) throw new Error("This personal Skill is unavailable.");
+      state.skill = skill;
+      state.draft = skill.content;
+      draftRevision += 1;
+      return true;
+    } catch (error) {
+      if (isCurrent(scope) && read === detailRead) state.error = error.message || String(error);
+      return false;
+    } finally {
+      if (isCurrent(scope) && read === detailRead) { state.reading = false; publish(); }
+    }
+  }
+  function setDraft(content) {
+    if (!canEdit()) return;
+    state.draft = content;
+    draftRevision += 1;
+    state.message = "";
+    publish();
+  }
+  function beginCreate() {
+    if (!acceptLeave()) return false;
+    clearEditor();
+    Object.assign(state, { creating: true, archived: false, error: "", message: "" });
+    publish();
+    return true;
+  }
+  function setCreationField(field, value) {
+    if (!state.creating || !canEdit()) return;
+    if (field !== "name" && field !== "description") return;
+    state[field] = value;
+    draftRevision += 1;
+    state.message = "";
+    publish();
+  }
+  function cancelCreate() {
+    if (!state.creating || !acceptLeave()) return false;
+    clearEditor();
+    state.error = "";
+    publish();
+    return true;
+  }
+  function creationValidationMessage() {
+    if (!state.name.trim() || state.name.length > 160) return "Enter a name of up to 160 characters.";
+    if (!state.description.trim() || state.description.length > 512) return "Enter a description of up to 512 characters.";
+    if (!state.draft.trim()) return "Enter the Skill content.";
+    if (new TextEncoder().encode(state.draft).length > 65_536) return "Skill content must be no larger than 64 KiB.";
+    return "";
+  }
+  async function create() {
+    if (!state.creating || !canEdit()) return false;
+    state.error = creationValidationMessage();
+    if (state.error) { publish(); return false; }
+    const scope = capture();
+    const input = { name: state.name, description: state.description, content: state.draft };
+    state.mutation = "create";
+    state.message = "";
+    publish();
+    try {
+      const { skill } = await client.createPersonalSkill(input, scope.environmentId);
+      if (!isCurrent(scope)) return false;
+      clearEditor();
+      Object.assign(state, { skill, draft: skill.content, archived: false, message: "Skill created." });
+      state.items = [...state.items.filter((item) => item.skillId !== skill.skillId), skill];
+      await refresh();
+      return true;
+    } catch (error) {
+      if (!isCurrent(scope)) return false;
+      state.error = error.message || String(error);
+      return false;
+    } finally {
+      if (isCurrent(scope)) { state.mutation = ""; publish(); }
+    }
+  }
+  function setArchived(archived) {
+    if (state.archived === archived) return true;
+    if (!acceptLeave()) return false;
+    state.archived = archived;
+    state.error = "";
+    state.message = "";
+    clearEditor();
+    publish();
+    return true;
+  }
+  async function reloadSelected() {
+    if (!state.skill || !acceptLeave()) return false;
+    return loadSkill(state.skill.skillId);
+  }
+  async function mutate(action) {
+    const skill = state.skill;
+    if (!skill || skill.source !== "personal" || state.mutation || state.reading) return false;
+    if (action === "save" && (!canEdit() || !isDirty() || !state.draft.trim())) return false;
+    if (action === "archive" && skill.archived) return false;
+    if (action === "restore" && !skill.archived) return false;
+    const scope = capture();
+    const content = state.draft;
+    state.mutation = action;
+    state.error = "";
+    state.message = "";
+    publish();
+    try {
+      const mutations = {
+        save: () => client.updatePersonalSkill(skill.skillId, content, skill.revision, scope.environmentId),
+        archive: () => client.archivePersonalSkill(skill.skillId, skill.revision, scope.environmentId),
+        restore: () => client.restorePersonalSkill(skill.skillId, skill.revision, scope.environmentId),
+      };
+      const result = await mutations[action]();
+      if (!isCurrent(scope)) return false;
+      if (action === "save") {
+        state.skill = result.skill;
+        state.draft = result.skill.content;
+        draftRevision += 1;
+      } else {
+        clearEditor();
+      }
+      state.message = { save: "Skill saved.", archive: "Skill archived.", restore: "Skill restored." }[action];
+      await refresh();
+      return true;
+    } catch (error) {
+      if (!isCurrent(scope)) return false;
+      state.error = error.code === "knowledge_skill_revision_conflict"
+        ? "This Skill changed elsewhere. Your draft is kept. Copy it before reloading the latest version."
+        : error.message || String(error);
+      return false;
+    } finally {
+      if (isCurrent(scope)) { state.mutation = ""; publish(); }
+    }
+  }
+  function environmentChanged() {
+    epoch += 1;
+    listRead += 1;
+    clearEditor();
+    Object.assign(state, { items: [], archived: false, loading: false, mutation: "", error: "", message: "" });
+    publish();
+    if (active) void refresh();
+  }
+  function setActive(value) {
+    const entering = value && !active;
+    active = value;
+    if (entering) void refresh();
+  }
+  return { snapshot, refresh, select, setDraft, setArchived, reloadSelected, prepareLeave,
+    isDirty, environmentChanged, setActive, beginCreate, setCreationField, cancelCreate,
+    save: () => state.creating ? create() : mutate("save"),
+    archive: () => mutate("archive"), restore: () => mutate("restore") };
+}

package/dist/src/web-ui/app/lib/conversation-role-model.d.ts

@@ -1,4 +1,6 @@
 import type { ConversationToolAction } from "./tool-activity-model.js";
+import type { RoleDelegation } from "./role-delegation-event.js";
+import type { RoleReturn } from "./role-return-event.js";
 
 export type ConversationRole =
   | "supervisor"
@@ -17,6 +19,9 @@ export interface ConversationRoleCard {
   summary: string;
   facts: string[];
   toolActions?: ConversationToolAction[];
+  skillActivities?: { summary: string; tone: string }[];
+  delegations?: RoleDelegation[];
+  returns?: RoleReturn[];
   active: boolean;
   tone: "active" | "failed" | "recorded";
 }