@ai-matrx/chat 0.1.74 → 0.2.0

package/dist/agents/redux/agent-shortcuts/thunks.js

@@ -0,0 +1,900 @@
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { supabase } from "../../../host/db.js";
+import { requireAuthenticatedSupabaseSession } from "../../../host/ui-slots.js";
+import { pgErrorToError } from "@ai-matrx/data";
+import { resolveSystemOrgId } from "../../../host/ui-slots.js";
+import { toGlobalOwnershipRecord } from "../../../host/ui-slots.js";
+import { assignField } from "@ai-matrx/agents/field-flags";
+function parseScopeMappings(raw) {
+  if (raw === null || raw === void 0) return null;
+  if (typeof raw !== "object" || Array.isArray(raw)) return null;
+  const out = {};
+  for (const [k, v] of Object.entries(raw)) {
+    if (typeof v === "string") out[k] = v;
+  }
+  return out;
+}
+function pickString(o, ...keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (typeof v === "string") return v;
+  }
+  return null;
+}
+function pickBool(o, fallback, ...keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (typeof v === "boolean") return v;
+  }
+  return fallback;
+}
+function pickNumber(o, fallback, ...keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (typeof v === "number") return v;
+  }
+  return fallback;
+}
+function pickJsonObject(o, ...keys) {
+  for (const k of keys) {
+    const v = o[k];
+    if (v && typeof v === "object" && !Array.isArray(v)) return v;
+  }
+  return null;
+}
+function menuItemToConfigFields(item) {
+  const o = item ?? {};
+  return {
+    displayMode: pickString(o, "display_mode", "result_display") ?? "modal-full",
+    showVariablePanel: pickBool(o, false, "show_variable_panel"),
+    variablesPanelStyle: pickString(o, "variables_panel_style") ?? "inline",
+    autoRun: pickBool(o, true, "auto_run"),
+    allowChat: pickBool(o, true, "allow_chat"),
+    showDefinitionMessages: pickBool(o, false, "show_definition_messages"),
+    showDefinitionMessageContent: pickBool(
+      o,
+      false,
+      "show_definition_message_content"
+    ),
+    hideReasoning: pickBool(o, false, "hide_reasoning"),
+    hideToolResults: pickBool(o, false, "hide_tool_results"),
+    responseDensity: pickString(o, "response_density") ?? "comfortable",
+    showPreExecutionGate: pickBool(
+      o,
+      false,
+      "show_pre_execution_gate",
+      "use_pre_execution_input"
+    ),
+    preExecutionMessage: pickString(o, "pre_execution_message"),
+    bypassGateSeconds: pickNumber(o, 3, "bypass_gate_seconds"),
+    defaultUserInput: pickString(o, "default_user_input"),
+    defaultVariables: pickJsonObject(
+      o,
+      "default_variables"
+    ),
+    contextOverrides: pickJsonObject(
+      o,
+      "context_overrides"
+    ),
+    llmOverrides: pickJsonObject(o, "llm_overrides"),
+    jsonExtraction: pickJsonObject(o, "json_extraction")
+  };
+}
+function parseVariableDefinitions(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (item) => item !== null && typeof item === "object" && "name" in item && typeof item.name === "string"
+  );
+}
+function parseContextPolicies(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(
+    (item) => item !== null && typeof item === "object" && "key" in item && typeof item.key === "string" && "type" in item
+  );
+}
+import {
+  upsertShortcut,
+  upsertShortcuts,
+  mergePartialShortcut,
+  setShortcutField,
+  setShortcutLoading,
+  setShortcutError,
+  setShortcutsStatus,
+  setShortcutsError,
+  markShortcutSaved,
+  rollbackShortcutOptimisticUpdate,
+  removeShortcut,
+  setInitialLoaded,
+  setContextLoaded,
+  setShortcutScopeLoaded
+} from "./slice.js";
+import {
+  buildScopeQueryString,
+  scopeIndexKey
+} from "../shared/scope.js";
+import {
+  upsertCategories as upsertCategoriesAction,
+  mergePartialCategory
+} from "../agent-shortcut-categories/slice.js";
+import { sklActions } from "../../../host/ui-slots.js";
+import { categoryRowToDef } from "../agent-shortcut-categories/converters.js";
+import {
+  selectShortcutById,
+  selectShortcutsInitialLoaded,
+  selectIsContextLoaded
+} from "./selectors.js";
+import {
+  dbRowToAgentShortcut,
+  agentShortcutToInsert,
+  agentShortcutToUpdate,
+  parseValueMappings,
+  readShortcutWritePolicies,
+  readShortcutNeverIncludeTools,
+  packShortcutMappingColumns,
+  shortcutMappingColumnsAreShared
+} from "./converters.js";
+const buildAgentShortcutMenu = createAsyncThunk("agentShortcut/buildMenu", async (arg, { dispatch, getState }) => {
+  if (selectShortcutsInitialLoaded(getState())) return [];
+  dispatch(setShortcutsStatus("loading"));
+  const placementTypes = arg && "placementTypes" in arg && arg.placementTypes ? arg.placementTypes : ["ai-action"];
+  const { data, error } = await supabase.rpc(SHORTCUT_RPCS.buildMenu, {
+    p_placement_types: placementTypes
+  });
+  if (error) {
+    dispatch(setShortcutsError(error.message));
+    dispatch(setShortcutsStatus("failed"));
+    throw pgErrorToError(error);
+  }
+  const results = data ?? [];
+  const allShortcuts = [];
+  for (const placement of results) {
+    for (const categoryGroup of placement.menu_data) {
+      const categoryId = categoryGroup.category.id;
+      for (const item of categoryGroup.shortcuts) {
+        const isVersion = item.resolved_id !== null && item.agent_id !== null && item.resolved_id !== item.agent_id;
+        const parsedVariableDefinitions = parseVariableDefinitions(
+          item.agent?.variable_definitions
+        );
+        const parsedContextPolicies = parseContextPolicies(
+          item.agent?.context_policies
+        );
+        const shortcut = {
+          id: item.id,
+          categoryId,
+          label: item.label,
+          description: item.description,
+          iconName: item.icon_name,
+          keyboardShortcut: item.keyboard_shortcut,
+          sortOrder: item.sort_order,
+          agentId: item.agent_id,
+          agentVersionId: isVersion ? item.resolved_id : null,
+          useLatest: item.use_latest,
+          resolvedId: item.resolved_id,
+          isVersion,
+          // The mandate this shortcut IS — every run goes through its key
+          // (aidream 1042 serves it on every menu item).
+          mandateKey: mandateKeyOfMenuItem(item),
+          agentName: item.agent?.name ?? null,
+          variableDefinitions: parsedVariableDefinitions,
+          contextPolicies: parsedContextPolicies,
+          enabledFeatures: item.enabled_features,
+          surfaceName: item.surface_name ?? null,
+          scopeMappings: parseScopeMappings(item.scope_mappings),
+          valueMappings: parseValueMappings(
+            item.value_mappings
+          ),
+          writePolicies: readShortcutWritePolicies(
+            item
+          ),
+          neverIncludeTools: readShortcutNeverIncludeTools(
+            item
+          ),
+          contextMappings: parseScopeMappings(item.context_mappings),
+          // AgentExecutionConfig bundle — read v2 columns with old-name fallback
+          // and DEFAULT_AGENT_EXECUTION_CONFIG defaults via the menu-item helper.
+          ...menuItemToConfigFields(item),
+          isActive: true,
+          // System menu shortcuts — no user/org ownership
+          userId: null,
+          organizationId: null,
+          projectId: null,
+          taskId: null,
+          createdAt: "",
+          updatedAt: ""
+        };
+        allShortcuts.push(shortcut);
+      }
+    }
+  }
+  dispatch(upsertShortcuts(allShortcuts));
+  dispatch(setInitialLoaded(true));
+  dispatch(setShortcutsStatus("succeeded"));
+  return results;
+});
+const fetchShortcutsForContext = createAsyncThunk(
+  "agentShortcut/fetchForContext",
+  async ({ projectId, taskId }, { dispatch, getState }) => {
+    const contextKey = taskId ? `task:${taskId}` : projectId ? `project:${projectId}` : "global";
+    if (selectIsContextLoaded(getState(), contextKey)) return;
+    const { data, error } = await supabase.rpc(
+      SHORTCUT_RPCS.forContext,
+      {
+        p_project_id: projectId ?? void 0,
+        p_task_id: taskId ?? void 0
+      }
+    );
+    if (error) throw pgErrorToError(error);
+    const rows = data ?? [];
+    const shortcuts = [];
+    for (const row of rows) {
+      const isVersion = row.resolved_id !== null && row.agent_id !== null && row.resolved_id !== row.agent_id;
+      const shortcut = {
+        id: row.shortcut_id,
+        categoryId: row.category_id,
+        label: row.label,
+        description: row.description,
+        iconName: row.icon_name,
+        keyboardShortcut: row.keyboard_shortcut,
+        sortOrder: row.sort_order,
+        agentId: row.agent_id,
+        agentVersionId: isVersion ? row.resolved_id : null,
+        useLatest: row.use_latest,
+        resolvedId: row.resolved_id,
+        isVersion,
+        agentName: row.agent_name ?? null,
+        variableDefinitions: parseVariableDefinitions(
+          row.agent_variable_definitions
+        ),
+        contextPolicies: parseContextPolicies(row.agent_context_policies),
+        enabledFeatures: row.enabled_features,
+        surfaceName: row.surface_name ?? null,
+        scopeMappings: parseScopeMappings(row.scope_mappings),
+        valueMappings: parseValueMappings(
+          row.value_mappings
+        ),
+        writePolicies: readShortcutWritePolicies(
+          row
+        ),
+        neverIncludeTools: readShortcutNeverIncludeTools(
+          row
+        ),
+        contextMappings: parseScopeMappings(row.context_mappings),
+        ...menuItemToConfigFields(row),
+        isActive: true,
+        userId: row.shortcut_user_id,
+        organizationId: row.shortcut_org_id,
+        projectId: row.shortcut_project_id ?? projectId ?? null,
+        taskId: row.shortcut_task_id ?? taskId ?? null,
+        createdAt: "",
+        updatedAt: ""
+      };
+      shortcuts.push(shortcut);
+    }
+    dispatch(upsertShortcuts(shortcuts));
+    dispatch(setContextLoaded({ key: contextKey, loaded: true }));
+  }
+);
+const fetchFullShortcut = createAsyncThunk(
+  "agentShortcut/fetchFull",
+  async (shortcutId, { dispatch }) => {
+    dispatch(setShortcutLoading({ id: shortcutId, loading: true }));
+    const { data, error } = await shortcutTable(supabase).select("*").eq("id", shortcutId).single();
+    dispatch(setShortcutLoading({ id: shortcutId, loading: false }));
+    if (error) {
+      dispatch(setShortcutError({ id: shortcutId, error: error.message }));
+      throw pgErrorToError(error);
+    }
+    dispatch(upsertShortcut(dbRowToAgentShortcut(data)));
+  }
+);
+const saveShortcut = createAsyncThunk(
+  "agentShortcut/save",
+  async (shortcutId, { dispatch, getState }) => {
+    const record = selectShortcutById(getState(), shortcutId);
+    if (!record || !record._dirty) return;
+    const dirtyPartial = {};
+    for (const field of Object.keys(
+      record._dirtyFields
+    )) {
+      assignField(dirtyPartial, field, record[field]);
+    }
+    if (shortcutMappingColumnsAreShared() && (dirtyPartial.valueMappings !== void 0 || dirtyPartial.writePolicies !== void 0)) {
+      dirtyPartial.valueMappings = record.valueMappings;
+      dirtyPartial.writePolicies = record.writePolicies ?? null;
+    }
+    const snapshot = { ...record._fieldHistory };
+    dispatch(setShortcutLoading({ id: shortcutId, loading: true }));
+    const { error } = await shortcutTable(supabase).update(agentShortcutToUpdate(dirtyPartial)).eq("id", shortcutId);
+    dispatch(setShortcutLoading({ id: shortcutId, loading: false }));
+    if (error) {
+      dispatch(rollbackShortcutOptimisticUpdate({ id: shortcutId, snapshot }));
+      dispatch(setShortcutError({ id: shortcutId, error: error.message }));
+      throw pgErrorToError(error);
+    }
+    dispatch(markShortcutSaved({ id: shortcutId }));
+  }
+);
+const saveShortcutField = createAsyncThunk(
+  "agentShortcut/saveField",
+  async ({ shortcutId, field, value }, { dispatch, getState }) => {
+    const existing = selectShortcutById(getState(), shortcutId);
+    const snapshot = existing ? { [field]: existing[field] } : {};
+    dispatch(setShortcutField({ id: shortcutId, field, value }));
+    const patch = shortcutMappingColumnsAreShared() && (field === "valueMappings" || field === "writePolicies") ? {
+      valueMappings: field === "valueMappings" ? value : existing?.valueMappings ?? null,
+      writePolicies: field === "writePolicies" ? value : existing?.writePolicies ?? null
+    } : { [field]: value };
+    const { error } = await shortcutTable(supabase).update(agentShortcutToUpdate(patch)).eq("id", shortcutId);
+    if (error) {
+      dispatch(rollbackShortcutOptimisticUpdate({ id: shortcutId, snapshot }));
+      dispatch(setShortcutError({ id: shortcutId, error: error.message }));
+      throw pgErrorToError(error);
+    }
+    dispatch(markShortcutSaved({ id: shortcutId }));
+  }
+);
+const createShortcut = createAsyncThunk("agentShortcut/create", async (shortcutData, { dispatch, getState }) => {
+  const userId = selectUserId(getState());
+  const organizationId = await ensureOrgId(shortcutData.organizationId);
+  const draft = {
+    ...shortcutData,
+    organizationId,
+    id: "",
+    // `null` is deliberate for global/org/project/task reach. Only an
+    // actually omitted value falls back to the current user.
+    userId: shortcutData.userId === void 0 ? userId : shortcutData.userId,
+    createdAt: "",
+    updatedAt: ""
+  };
+  const { data, error } = await shortcutTable(supabase).insert(agentShortcutToInsert(draft)).select().single();
+  if (error) throw pgErrorToError(error);
+  const newShortcut = toGlobalOwnershipRecord(
+    dbRowToAgentShortcut(data),
+    await resolveSystemOrgId()
+  );
+  dispatch(upsertShortcut(newShortcut));
+  return newShortcut.id;
+});
+const deleteShortcut = createAsyncThunk(
+  "agentShortcut/delete",
+  async (shortcutId, { dispatch }) => {
+    const { error } = await shortcutTable(supabase).update({ deleted_at: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", shortcutId);
+    if (error) throw pgErrorToError(error);
+    dispatch(removeShortcut(shortcutId));
+  }
+);
+const fetchUserShortcuts = createAsyncThunk("agentShortcut/fetchUserShortcuts", async () => {
+  const { data, error } = await supabase.rpc(SHORTCUT_RPCS.userShortcuts);
+  if (error) throw pgErrorToError(error);
+  return data ?? [];
+});
+const duplicateShortcut = createAsyncThunk("agentShortcut/duplicate", async (arg, { dispatch }) => {
+  const shortcutId = typeof arg === "string" ? arg : arg.id;
+  const targetCategoryId = typeof arg === "string" ? void 0 : arg.categoryId;
+  const { data, error } = await supabase.rpc(SHORTCUT_RPCS.duplicate, {
+    p_shortcut_id: shortcutId,
+    p_organization_id: await ensureOrgId(null)
+  });
+  if (error) throw pgErrorToError(error);
+  const newShortcutId = data;
+  await dispatch(fetchFullShortcut(newShortcutId));
+  if (targetCategoryId) {
+    await dispatch(
+      saveShortcutField({
+        shortcutId: newShortcutId,
+        field: "categoryId",
+        value: targetCategoryId
+      })
+    );
+  }
+  return newShortcutId;
+});
+const promoteShortcutToGlobal = createAsyncThunk(
+  "agentShortcut/promoteToGlobal",
+  async ({ shortcutId, targetCategoryId, label }, { dispatch }) => {
+    const { data, error } = await supabase.rpc(
+      SHORTCUT_RPCS.promoteToGlobal,
+      {
+        p_shortcut_id: shortcutId,
+        p_target_category_id: targetCategoryId,
+        p_label: label && label.trim().length > 0 ? label.trim() : void 0
+      }
+    );
+    if (error) throw pgErrorToError(error);
+    const newShortcutId = data;
+    await dispatch(fetchFullShortcut(newShortcutId));
+    return newShortcutId;
+  }
+);
+const listNonGlobalShortcutsForAdmin = createAsyncThunk("agentShortcut/listNonGlobalForAdmin", async () => {
+  await requireAuthenticatedSupabaseSession(supabase);
+  const { data, error } = await supabase.rpc(
+    SHORTCUT_RPCS.listNonGlobalForAdmin
+  );
+  if (error) throw pgErrorToError(error);
+  return data ?? [];
+});
+const createShortcutForAgent = createAsyncThunk("agentShortcut/createForAgent", async (params, { dispatch, getState }) => {
+  const userId = selectUserId(getState());
+  const organizationId = await ensureOrgId(params.p_organization_id);
+  const rpcParams = {
+    ...params,
+    p_organization_id: organizationId,
+    p_user_id: params.p_user_id ?? (!params.p_organization_id && !params.p_project_id && !params.p_task_id ? userId : null)
+  };
+  const { data, error } = await supabase.rpc(SHORTCUT_RPCS.create, {
+    p_agent_id: rpcParams.p_agent_id,
+    p_category_id: rpcParams.p_category_id,
+    p_label: rpcParams.p_label,
+    p_use_latest: rpcParams.p_use_latest,
+    p_user_id: rpcParams.p_user_id ?? void 0,
+    p_organization_id: rpcParams.p_organization_id ?? void 0,
+    p_project_id: rpcParams.p_project_id ?? void 0,
+    p_task_id: rpcParams.p_task_id ?? void 0
+  });
+  if (error) throw pgErrorToError(error);
+  const newShortcutId = data;
+  await dispatch(fetchFullShortcut(newShortcutId));
+  return newShortcutId;
+});
+const syncUserShortcutToSlice = createAsyncThunk("agentShortcut/syncFromManagement", async (item, { dispatch }) => {
+  dispatch(
+    mergePartialShortcut({
+      id: item.id,
+      label: item.label,
+      description: item.description,
+      iconName: item.icon_name,
+      keyboardShortcut: item.keyboard_shortcut,
+      sortOrder: item.sort_order,
+      categoryId: item.category_id,
+      agentId: item.agent_id,
+      agentVersionId: item.agent_version_id,
+      useLatest: item.use_latest,
+      enabledFeatures: item.enabled_features,
+      surfaceName: item.surface_name ?? null,
+      scopeMappings: item.scope_mappings,
+      valueMappings: parseValueMappings(item.value_mappings),
+      writePolicies: readShortcutWritePolicies(
+        item
+      ),
+      neverIncludeTools: readShortcutNeverIncludeTools(
+        item
+      ),
+      contextMappings: item.context_mappings,
+      ...menuItemToConfigFields(item),
+      isActive: item.is_active,
+      userId: item.user_id,
+      organizationId: item.organization_id,
+      projectId: item.project_id,
+      taskId: item.task_id,
+      createdAt: item.created_at,
+      updatedAt: item.updated_at
+    })
+  );
+});
+function shortcutRowToFrontend(row) {
+  const isVersion = !row.use_latest && row.agent_version_id != null;
+  return {
+    id: row.id,
+    categoryId: row.category_id,
+    label: row.label,
+    description: row.description,
+    iconName: row.icon_name,
+    keyboardShortcut: row.keyboard_shortcut,
+    sortOrder: row.sort_order ?? 0,
+    agentId: row.agent_id,
+    agentVersionId: row.agent_version_id,
+    useLatest: row.use_latest ?? false,
+    resolvedId: isVersion ? row.agent_version_id : row.agent_id,
+    isVersion,
+    agentName: null,
+    variableDefinitions: [],
+    contextPolicies: [],
+    enabledFeatures: row.enabled_features ?? [],
+    surfaceName: row.surface_name ?? null,
+    scopeMappings: parseScopeMappings(row.scope_mappings),
+    valueMappings: parseValueMappings(row.value_mappings),
+    writePolicies: readShortcutWritePolicies(
+      row
+    ),
+    neverIncludeTools: readShortcutNeverIncludeTools(
+      row
+    ),
+    contextMappings: parseScopeMappings(row.context_mappings),
+    ...menuItemToConfigFields(row),
+    // Mandate identity rides the same REST rows (census #47) — the route
+    // selects `*` through `shortcutTable()`, so `mandate.vw_shortcut`'s two
+    // extra columns arrive here untouched the moment the switch flips.
+    mandateId: mandateIdOfShortcutRow(row),
+    mandateKey: mandateKeyOfShortcutRow(row),
+    isActive: row.is_active,
+    userId: row.created_by,
+    organizationId: row.organization_id,
+    projectId: row.project_id,
+    taskId: row.task_id,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function shortcutToApiBody(patch) {
+  const out = {};
+  if (patch.categoryId !== void 0) out.category_id = patch.categoryId;
+  if (patch.label !== void 0) out.label = patch.label;
+  if (patch.description !== void 0) out.description = patch.description;
+  if (patch.iconName !== void 0) out.icon_name = patch.iconName;
+  if (patch.keyboardShortcut !== void 0)
+    out.keyboard_shortcut = patch.keyboardShortcut;
+  if (patch.sortOrder !== void 0) out.sort_order = patch.sortOrder;
+  if (patch.agentId !== void 0) out.agent_id = patch.agentId;
+  if (patch.agentVersionId !== void 0)
+    out.agent_version_id = patch.agentVersionId;
+  if (patch.useLatest !== void 0) out.use_latest = patch.useLatest;
+  if (patch.enabledFeatures !== void 0)
+    out.enabled_features = patch.enabledFeatures;
+  if (patch.surfaceName !== void 0) out.surface_name = patch.surfaceName;
+  if (patch.scopeMappings !== void 0)
+    out.scope_mappings = patch.scopeMappings;
+  if (patch.valueMappings !== void 0 || patch.writePolicies !== void 0) {
+    if (shortcutMappingColumnsAreShared() && (patch.valueMappings === void 0 || patch.writePolicies === void 0)) {
+      console.error(
+        "[agent-shortcuts] REST value_mappings patch is one-sided \u2014 valueMappings and writePolicies share one column; the missing half is being CLEARED. Pass both (updateShortcut fills them automatically).",
+        {
+          hasValueMappings: patch.valueMappings !== void 0,
+          hasWritePolicies: patch.writePolicies !== void 0
+        }
+      );
+    }
+    const columns = packShortcutMappingColumns(
+      patch.valueMappings ?? null,
+      patch.writePolicies ?? null
+    );
+    if (shortcutMappingColumnsAreShared() || patch.valueMappings !== void 0)
+      out.value_mappings = columns.value_mappings;
+    if (!shortcutMappingColumnsAreShared() && patch.writePolicies !== void 0)
+      out.write_policies = columns.write_policies;
+  }
+  if (patch.contextMappings !== void 0)
+    out.context_mappings = patch.contextMappings;
+  if (patch.displayMode !== void 0) out.display_mode = patch.displayMode;
+  if (patch.showVariablePanel !== void 0)
+    out.show_variable_panel = patch.showVariablePanel;
+  if (patch.variablesPanelStyle !== void 0)
+    out.variables_panel_style = patch.variablesPanelStyle;
+  if (patch.allowChat !== void 0) out.allow_chat = patch.allowChat;
+  if (patch.autoRun !== void 0) out.auto_run = patch.autoRun;
+  if (patch.showDefinitionMessages !== void 0)
+    out.show_definition_messages = patch.showDefinitionMessages;
+  if (patch.showDefinitionMessageContent !== void 0)
+    out.show_definition_message_content = patch.showDefinitionMessageContent;
+  if (patch.hideReasoning !== void 0)
+    out.hide_reasoning = patch.hideReasoning;
+  if (patch.hideToolResults !== void 0)
+    out.hide_tool_results = patch.hideToolResults;
+  if (patch.showPreExecutionGate !== void 0)
+    out.show_pre_execution_gate = patch.showPreExecutionGate;
+  if (patch.preExecutionMessage !== void 0)
+    out.pre_execution_message = patch.preExecutionMessage;
+  if (patch.bypassGateSeconds !== void 0)
+    out.bypass_gate_seconds = patch.bypassGateSeconds;
+  if (patch.defaultUserInput !== void 0)
+    out.default_user_input = patch.defaultUserInput;
+  if (patch.defaultVariables !== void 0)
+    out.default_variables = patch.defaultVariables;
+  if (patch.contextOverrides !== void 0)
+    out.context_overrides = patch.contextOverrides;
+  if (patch.llmOverrides !== void 0)
+    out.llm_overrides = patch.llmOverrides;
+  if (patch.jsonExtraction !== void 0)
+    out.json_extraction = patch.jsonExtraction;
+  if (patch.isActive !== void 0) out.is_active = patch.isActive;
+  if (patch.userId !== void 0) out.created_by = patch.userId;
+  if (patch.organizationId !== void 0)
+    out.organization_id = patch.organizationId;
+  return out;
+}
+async function parseJsonOrThrow(response) {
+  if (!response.ok) {
+    let message = `HTTP ${response.status} ${response.statusText}`;
+    try {
+      const body = await response.json();
+      if (body && typeof body === "object") {
+        const b = body;
+        const parts = [];
+        if (typeof b.error === "string") parts.push(b.error);
+        if (typeof b.details === "string") parts.push(`Details: ${b.details}`);
+        if (typeof b.hint === "string") parts.push(`Hint: ${b.hint}`);
+        if (parts.length > 0) message = parts.join(" \u2014 ");
+      }
+    } catch {
+    }
+    throw new Error(message);
+  }
+  return await response.json();
+}
+const fetchShortcutsForScope = createAsyncThunk("agentShortcut/fetchForScope", async (scopeRef, { dispatch }) => {
+  dispatch(setShortcutsStatus("loading"));
+  try {
+    const qs = buildScopeQueryString(scopeRef);
+    const response = await fetch(`/api/agent-shortcuts?${qs}`, {
+      method: "GET",
+      credentials: "include"
+    });
+    const payload = await parseJsonOrThrow(
+      response
+    );
+    const shortcuts = payload.data.map(shortcutRowToFrontend);
+    dispatch(upsertShortcuts(shortcuts));
+    dispatch(setShortcutScopeLoaded({ scopeRef, loaded: true }));
+    dispatch(setShortcutsStatus("succeeded"));
+    return shortcuts;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to load shortcuts";
+    dispatch(setShortcutsError(message));
+    dispatch(setShortcutsStatus("failed"));
+    throw pgErrorToError(error);
+  }
+});
+const updateShortcut = createAsyncThunk("agentShortcut/update", async (input, { dispatch, getState }) => {
+  const { id, ...patch } = input;
+  const existing = selectShortcutById(getState(), id);
+  if (shortcutMappingColumnsAreShared() && patch.valueMappings !== void 0 !== (patch.writePolicies !== void 0)) {
+    if (!existing) {
+      console.warn(
+        "[agent-shortcuts] updateShortcut: one-sided value_mappings patch with no loaded record \u2014 the missing half falls back to null and any stored value for it is cleared",
+        { id }
+      );
+    }
+    if (patch.valueMappings === void 0) {
+      patch.valueMappings = existing?.valueMappings ?? null;
+    }
+    if (patch.writePolicies === void 0) {
+      patch.writePolicies = existing?.writePolicies ?? null;
+    }
+  }
+  const snapshot = existing ? Object.keys(patch).reduce((acc, field) => {
+    assignField(acc, field, existing[field]);
+    return acc;
+  }, {}) : {};
+  dispatch(setShortcutLoading({ id, loading: true }));
+  try {
+    const response = await fetch(`/api/agent-shortcuts/${id}`, {
+      method: "PATCH",
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(shortcutToApiBody(patch))
+    });
+    const result = await parseJsonOrThrow(response);
+    const shortcut = shortcutRowToFrontend(result.data);
+    dispatch(upsertShortcut(shortcut));
+    dispatch(markShortcutSaved({ id }));
+    return shortcut;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to update shortcut";
+    dispatch(rollbackShortcutOptimisticUpdate({ id, snapshot }));
+    dispatch(setShortcutError({ id, error: message }));
+    throw pgErrorToError(error);
+  } finally {
+    dispatch(setShortcutLoading({ id, loading: false }));
+  }
+});
+function extractScopeFromUnifiedItem(item) {
+  return {
+    userId: item.user_id ?? null,
+    organizationId: item.organization_id ?? null,
+    projectId: item.project_id ?? null,
+    taskId: item.task_id ?? null
+  };
+}
+const inflightUnifiedMenu = /* @__PURE__ */ new Map();
+function unifiedMenuLoadedKey(ref) {
+  return `unified-menu:${scopeIndexKey(ref)}`;
+}
+const fetchUnifiedMenu = createAsyncThunk(
+  "agentShortcut/fetchUnifiedMenu",
+  async (scopeRef, { dispatch, getState }) => {
+    const ref = scopeRef && typeof scopeRef === "object" && "scope" in scopeRef ? { scope: scopeRef.scope, scopeId: scopeRef.scopeId ?? null } : { scope: "global", scopeId: null };
+    const key = scopeIndexKey(ref);
+    const existing = inflightUnifiedMenu.get(key);
+    if (existing) return existing;
+    const promise = (async () => {
+      dispatch(setShortcutsStatus("loading"));
+      try {
+        const qs = buildScopeQueryString(ref);
+        const response = await fetch(`/api/agent-context-menu?${qs}`, {
+          method: "GET",
+          credentials: "include"
+        });
+        const payload = await parseJsonOrThrow(response);
+        const categoryDefs = [];
+        const shortcutDefs = [];
+        const contentBlockDefs = [];
+        if (true) {
+          const placementSummary = (payload.data ?? []).map((p) => ({
+            placement_type: p.placement_type,
+            categories: (p.categories_flat ?? []).length,
+            total_items: (p.categories_flat ?? []).reduce(
+              (sum, g) => sum + (g.items?.length ?? 0),
+              0
+            )
+          }));
+        }
+        for (const placement of payload.data ?? []) {
+          for (const group of placement.categories_flat ?? []) {
+            const categoryRow = {
+              id: group.category.id,
+              label: group.category.label,
+              description: group.category.description,
+              icon_name: group.category.icon_name,
+              color: group.category.color ?? null,
+              sort_order: group.category.sort_order ?? 0,
+              placement_type: group.category.placement_type ?? placement.placement_type,
+              parent_category_id: group.category.parent_category_id,
+              enabled_features: group.category.enabled_features ?? null,
+              metadata: group.category.metadata ?? null,
+              is_active: group.category.is_active ?? true,
+              user_id: group.category.user_id ?? null,
+              organization_id: group.category.organization_id ?? null,
+              project_id: group.category.project_id ?? null,
+              task_id: group.category.task_id ?? null,
+              created_at: group.category.created_at ?? "",
+              updated_at: group.category.updated_at ?? ""
+            };
+            categoryDefs.push(categoryRowToDef(categoryRow));
+            for (const item of group.items ?? []) {
+              if (item.type === "agent_shortcut") {
+                const shortcutItem = item;
+                const scopeFields = extractScopeFromUnifiedItem(shortcutItem);
+                shortcutDefs.push(
+                  unifiedMenuItemToShortcut({
+                    ...shortcutItem,
+                    category_id: shortcutItem.category_id ?? group.category.id,
+                    user_id: scopeFields.userId,
+                    organization_id: scopeFields.organizationId,
+                    project_id: scopeFields.projectId,
+                    task_id: scopeFields.taskId,
+                    created_at: shortcutItem.created_at ?? "",
+                    updated_at: shortcutItem.updated_at ?? ""
+                  })
+                );
+              } else if (item.type === "content_block") {
+                const blockItem = item;
+                const scopeFields = extractScopeFromUnifiedItem(blockItem);
+                contentBlockDefs.push({
+                  id: blockItem.id,
+                  blockId: blockItem.block_id,
+                  categoryId: blockItem.category_id ?? group.category.id,
+                  label: blockItem.label,
+                  description: blockItem.description,
+                  iconName: blockItem.icon_name,
+                  sortOrder: blockItem.sort_order ?? 0,
+                  template: blockItem.template,
+                  // Merge is Object.assign-based — omit (rather than null out)
+                  // classification fields if a stale/cached payload lacks them.
+                  ...blockItem.block_type != null ? { blockType: blockItem.block_type } : {},
+                  ...blockItem.skill_id !== void 0 ? { skillId: blockItem.skill_id } : {},
+                  ...blockItem.visibility != null ? {
+                    visibility: blockItem.visibility,
+                    isPublic: blockItem.visibility === "public"
+                  } : {},
+                  isActive: blockItem.is_active ?? true,
+                  userId: scopeFields.userId,
+                  organizationId: scopeFields.organizationId,
+                  projectId: scopeFields.projectId,
+                  taskId: scopeFields.taskId
+                });
+              }
+            }
+          }
+        }
+        if (categoryDefs.length > 0) {
+          dispatch(upsertCategoriesAction(categoryDefs));
+        }
+        if (shortcutDefs.length > 0) {
+          dispatch(upsertShortcuts(shortcutDefs));
+        }
+        if (contentBlockDefs.length > 0) {
+          dispatch(sklActions.renderDefinitionsMerged(contentBlockDefs));
+        }
+        dispatch(setShortcutScopeLoaded({ scopeRef: ref, loaded: true }));
+        dispatch(setContextLoaded({ key: unifiedMenuLoadedKey(ref), loaded: true }));
+        dispatch(setShortcutsStatus("succeeded"));
+        return { placements: payload.data ?? [] };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to load unified menu";
+        dispatch(setShortcutsError(message));
+        dispatch(setShortcutsStatus("failed"));
+        throw pgErrorToError(error);
+      } finally {
+        inflightUnifiedMenu.delete(key);
+      }
+    })();
+    inflightUnifiedMenu.set(key, promise);
+    return promise;
+  },
+  {
+    condition: (arg, { getState }) => {
+      const force = arg && typeof arg === "object" && "force" in arg ? Boolean(arg.force) : false;
+      if (force) return true;
+      const ref = arg && typeof arg === "object" && "scope" in arg ? { scope: arg.scope, scopeId: arg.scopeId ?? null } : { scope: "global", scopeId: null };
+      const state = getState();
+      if (state.agentShortcut.contextLoaded?.[unifiedMenuLoadedKey(ref)]) return false;
+      return true;
+    }
+  }
+);
+const ensureShortcutLoaded = createAsyncThunk(
+  "agentShortcut/ensureLoaded",
+  async (shortcutId, { dispatch, getState }) => {
+    const existing = getState().agentShortcut.shortcuts[shortcutId];
+    if (existing) return;
+    await dispatch(fetchUnifiedMenu({ scope: "user", scopeId: null })).unwrap();
+    const after = getState().agentShortcut.shortcuts[shortcutId];
+    if (!after) {
+      throw new Error(
+        `Shortcut ${shortcutId} not available to this user. The id may be stale, the shortcut may be inactive, or the user lacks access. (Menu fetch completed without returning this shortcut.)`
+      );
+    }
+  }
+);
+function unifiedMenuItemToShortcut(item) {
+  const loose = item;
+  const variableDefinitions = parseVariableDefinitions(
+    loose.agent_variable_definitions ?? loose.agent?.variable_definitions
+  );
+  const contextPolicies = parseContextPolicies(
+    loose.agent_context_policies ?? loose.agent?.context_policies
+  );
+  const agentName = loose.agent_name ?? loose.agent?.name ?? null;
+  const base = shortcutRowToFrontend(item);
+  return {
+    ...base,
+    agentName,
+    variableDefinitions,
+    contextPolicies
+  };
+}
+import {
+  fetchCategoriesForScope,
+  createCategory,
+  updateCategory,
+  deleteCategory
+} from "../agent-shortcut-categories/thunks.js";
+import {
+  shortcutTable,
+  SHORTCUT_RPCS,
+  mandateIdOfShortcutRow,
+  mandateKeyOfShortcutRow
+} from "../../../ui/mandates-storage/shortcutStorage.js";
+import { storedMandateKey } from "@ai-matrx/agents/mandates";
+import { selectUserId } from "../../../host/identity.js";
+import { ensureOrgId } from "../../../host/org.js";
+function mandateKeyOfMenuItem(item) {
+  const key = item.mandate_key ?? null;
+  return key ? storedMandateKey(key) : null;
+}
+export {
+  buildAgentShortcutMenu,
+  createCategory,
+  createShortcut,
+  createShortcutForAgent,
+  deleteCategory,
+  deleteShortcut,
+  duplicateShortcut,
+  ensureShortcutLoaded,
+  fetchCategoriesForScope,
+  fetchFullShortcut,
+  fetchShortcutsForContext,
+  fetchShortcutsForScope,
+  fetchUnifiedMenu,
+  fetchUserShortcuts,
+  listNonGlobalShortcutsForAdmin,
+  mergePartialCategory,
+  promoteShortcutToGlobal,
+  saveShortcut,
+  saveShortcutField,
+  shortcutRowToFrontend,
+  syncUserShortcutToSlice,
+  unifiedMenuLoadedKey,
+  updateCategory,
+  updateShortcut
+};