@yemi33/minions 0.1.2448 → 0.1.2449

package/dashboard/shared/cc-limits.js

@@ -0,0 +1,79 @@
+// dashboard/shared/cc-limits.js
+//
+// Shared client-side mirror of the server's Command Center API length limits
+// (engine/api/cc-api-validation.js CC_API_LIMITS). Used by BOTH the classic
+// dashboard (dashboard/js/command-center.js) and Slim
+// (dashboard/slim/js/command-send.js) so an oversized message is rejected on
+// the client BEFORE it is cleared from the composer, queued, rendered, or
+// persisted — and so every transcript entry is bounded to the server limit,
+// meaning a previously-persisted oversized message can no longer poison future
+// sends via the carried transcript (W-mscjjqdh).
+//
+// The REAL server values are injected into the page as window.MINIONS_CC_LIMITS
+// by both serve paths (dashboard.js buildDashboardHtml + serveSlimUx, sourced
+// from ccApiValidation.CC_API_LIMITS). The FALLBACK_LIMITS below only apply when
+// that global is missing (e.g. a stale cached page) and MUST match the server
+// constant — the whole point of the injection is that client and server limits
+// do not silently drift, so never bump a number here without changing the
+// server. Every helper reads the limits at CALL time so a late injection is
+// still honored.
+
+(function () {
+  'use strict';
+
+  var FALLBACK_LIMITS = {
+    messageMaxChars: 100000,
+    transcriptTextMaxChars: 65536,
+    transcriptMaxEntries: 20,
+  };
+
+  function _positive(value, fallback) {
+    return (typeof value === 'number' && isFinite(value) && value > 0) ? value : fallback;
+  }
+
+  function _limits() {
+    var injected = (typeof window !== 'undefined' && window.MINIONS_CC_LIMITS) || {};
+    return {
+      messageMaxChars: _positive(injected.messageMaxChars, FALLBACK_LIMITS.messageMaxChars),
+      transcriptTextMaxChars: _positive(injected.transcriptTextMaxChars, FALLBACK_LIMITS.transcriptTextMaxChars),
+      transcriptMaxEntries: _positive(injected.transcriptMaxEntries, FALLBACK_LIMITS.transcriptMaxEntries),
+    };
+  }
+
+  // Returns { ok, length, limit }. A message longer than messageMaxChars is
+  // rejected by the server as `body.message has an invalid length`; guard it on
+  // the client so the composer is never cleared and the turn is never persisted.
+  function checkMessage(text) {
+    var s = typeof text === 'string' ? text : '';
+    var limit = _limits().messageMaxChars;
+    return { ok: s.length <= limit, length: s.length, limit: limit };
+  }
+
+  // Human-readable, actionable validation message for an oversized send. The
+  // rejected text stays in the composer, so tell the user that explicitly.
+  function messageTooLongText(length, limit) {
+    var lim = _positive(limit, _limits().messageMaxChars);
+    var len = (typeof length === 'number' && isFinite(length)) ? length : 0;
+    return 'Message is too long (' + len.toLocaleString() + ' characters; limit is '
+      + lim.toLocaleString() + '). Shorten it and send again — your text is still in the box.';
+  }
+
+  // Bound a single transcript entry's text to the server's transcriptTextMaxChars
+  // so a previously-persisted oversized message cannot poison future sends
+  // (`body.transcript[N].text has an invalid length`). Truncation is safe: the
+  // transcript is best-effort carry-over context, not the authoritative turn.
+  function boundTranscriptText(text) {
+    var s = typeof text === 'string' ? text : '';
+    var limit = _limits().transcriptTextMaxChars;
+    return s.length > limit ? s.slice(0, limit) : s;
+  }
+
+  window.MinionsCcLimits = {
+    get messageMaxChars() { return _limits().messageMaxChars; },
+    get transcriptTextMaxChars() { return _limits().transcriptTextMaxChars; },
+    get transcriptMaxEntries() { return _limits().transcriptMaxEntries; },
+    checkMessage: checkMessage,
+    messageTooLongText: messageTooLongText,
+    boundTranscriptText: boundTranscriptText,
+  };
+})();

package/dashboard/shared/pr-filters.js

@@ -1,6 +1,10 @@
 // Shared PR filter semantics. Slim embeds the classic /prs screen, and both
 // bundles load this helper so lifecycle and legacy-field normalization stay
 // identical across surfaces.
+//
+// Only the PR-specific normalizers live here; the dimension/match/options
+// machinery comes from shared/record-filters.js, which the classic Work Items
+// filter bar reuses too.
 var PR_FILTER_DIMENSIONS = ['author', 'lifecycle', 'project', 'review', 'build'];
 var PR_LIFECYCLE_FILTER_LABELS = {
   open: 'Open / active',
@@ -14,7 +18,7 @@ var PR_FILTER_OPTION_ORDER = {
 };
 
 function _prFilterText(value) {
-  return typeof value === 'string' ? value.trim() : '';
+  return window.MinionsRecordFilters.text(value);
 }
 
 function _prFilterName(value) {
@@ -28,15 +32,17 @@ function _prFilterName(value) {
 }
 
 function _prFilterKey(value) {
-  return _prFilterText(value).toLowerCase();
+  return window.MinionsRecordFilters.key(value);
 }
 
 function normalizePrAuthor(pr) {
   if (!pr || typeof pr !== 'object') return '';
+  // Real author only. Deliberately NOT falling back to pr.agent: the Minions
+  // agent is a separate identity (W-mscibegy005e8b74) and a legacy record with
+  // no author must group/render as Unknown rather than borrow the agent name.
   return _prFilterName(pr.author)
     || _prFilterName(pr.createdBy)
-    || _prFilterName(pr.created_by)
-    || _prFilterName(pr.agent);
+    || _prFilterName(pr.created_by);
 }
 
 function normalizePrLifecycleStatus(pr) {
@@ -108,52 +114,29 @@ function _prFilterEntry(pr, dimension) {
 }
 
 function _formatPrFilterLabel(value) {
-  var text = _prFilterText(value).replace(/[-_]+/g, ' ');
-  return text ? text.charAt(0).toUpperCase() + text.slice(1) : '';
+  return window.MinionsRecordFilters.label(value);
 }
 
+var _prFilterEngine = window.MinionsRecordFilters.create({
+  dimensions: PR_FILTER_DIMENSIONS,
+  entry: _prFilterEntry,
+  order: PR_FILTER_OPTION_ORDER,
+});
+
 function getPrFilterValue(pr, dimension) {
-  var entry = _prFilterEntry(pr, dimension);
-  return entry ? entry.value : '';
+  return _prFilterEngine.value(pr, dimension);
 }
 
 function matchesPullRequestFilters(pr, filters) {
-  filters = filters || {};
-  for (var i = 0; i < PR_FILTER_DIMENSIONS.length; i++) {
-    var dimension = PR_FILTER_DIMENSIONS[i];
-    var selected = _prFilterKey(filters[dimension]);
-    if (selected && getPrFilterValue(pr, dimension) !== selected) return false;
-  }
-  return true;
+  return _prFilterEngine.matches(pr, filters);
 }
 
 function filterPullRequests(prs, filters) {
-  if (!Array.isArray(prs)) return [];
-  return prs.filter(function(pr) { return matchesPullRequestFilters(pr, filters); });
+  return _prFilterEngine.filter(prs, filters);
 }
 
 function getPrFilterOptions(prs) {
-  var result = {};
-  var records = Array.isArray(prs) ? prs : [];
-  PR_FILTER_DIMENSIONS.forEach(function(dimension) {
-    var seen = new Map();
-    records.forEach(function(pr) {
-      var entry = _prFilterEntry(pr, dimension);
-      if (entry && !seen.has(entry.value)) seen.set(entry.value, entry);
-    });
-    var order = PR_FILTER_OPTION_ORDER[dimension] || [];
-    result[dimension] = Array.from(seen.values()).sort(function(a, b) {
-      var ai = order.indexOf(a.value);
-      var bi = order.indexOf(b.value);
-      if (ai !== -1 || bi !== -1) {
-        if (ai === -1) return 1;
-        if (bi === -1) return -1;
-        if (ai !== bi) return ai - bi;
-      }
-      return a.label.localeCompare(b.label, undefined, { sensitivity: 'base' });
-    });
-  });
-  return result;
+  return _prFilterEngine.options(prs);
 }
 
 window.MinionsPrFilters = {

package/dashboard/shared/project-git-summary.js

@@ -161,7 +161,7 @@ function summarizeProjectGit(p) {
   var branchDiffersFromMain = !!(mainBranch && branch !== mainBranch);
   var comparator = mainBranch || remoteDefault;
   // Comparator for ahead/behind is origin/<mainBranch || remoteDefaultBranch>
-  // (engine/queries.js _probeProjectGitStatus), never the branch's own upstream.
+  // (engine/core/queries.js _probeProjectGitStatus), never the branch's own upstream.
   var comparatorRef = mainBranch || remoteDefault;
   var branchDiffersFromComparator = !!(comparator && branch !== comparatorRef);
   var showAheadBehind = ahead !== null && behind !== null && (ahead > 0 || behind > 0);

package/dashboard/shared/record-filters.js

@@ -0,0 +1,169 @@
+// Generic record-filter semantics shared by every filterable classic table.
+//
+// Both filterable classic tables (Pull Requests, Work Items) need exactly the
+// same machinery: normalize a record to a comparable key per dimension, AND the
+// selected dimensions together, derive the <select> options from the records
+// actually present, and drive the filter-bar DOM. Only the per-dimension
+// normalizers differ. This module owns the common half so the two surfaces
+// cannot drift ("reuse, don't fork"); callers supply just an `entry` function.
+//
+// Option VALUES are always derived from the records present, so no surface
+// maintains a taxonomy that can fall out of sync with the engine. `order` only
+// supplies the display ORDER; unknown values sort alphabetically after it.
+
+function recordFilterText(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function recordFilterKey(value) {
+  return recordFilterText(value).toLowerCase();
+}
+
+function formatRecordFilterLabel(value) {
+  var text = recordFilterText(value).replace(/[-_]+/g, ' ');
+  return text ? text.charAt(0).toUpperCase() + text.slice(1) : '';
+}
+
+// `entry(record, dimension)` returns `{ value, label }` or a falsy value when
+// the record carries nothing for that dimension. A record with no value is
+// never given a selectable option (it would read as an "empty" choice) but is
+// still retained under "All".
+//
+// `order` maps a dimension to an array of values defining display order, or to
+// a function returning one — a function lets a caller defer to a vocabulary
+// that is bootstrapped onto `window` after this module is evaluated.
+function createRecordFilters(spec) {
+  var dimensions = (spec && spec.dimensions) || [];
+  var entry = (spec && spec.entry) || function () { return null; };
+  var order = (spec && spec.order) || {};
+
+  function resolveOrder(dimension) {
+    var configured = order[dimension];
+    if (typeof configured === 'function') configured = configured();
+    return Array.isArray(configured) ? configured : [];
+  }
+
+  function value(record, dimension) {
+    var resolved = entry(record, dimension);
+    return resolved ? resolved.value : '';
+  }
+
+  function matches(record, filters) {
+    filters = filters || {};
+    for (var i = 0; i < dimensions.length; i++) {
+      var dimension = dimensions[i];
+      var selected = recordFilterKey(filters[dimension]);
+      if (selected && value(record, dimension) !== selected) return false;
+    }
+    return true;
+  }
+
+  function filter(records, filters) {
+    if (!Array.isArray(records)) return [];
+    return records.filter(function (record) { return matches(record, filters); });
+  }
+
+  function options(records) {
+    var result = {};
+    var list = Array.isArray(records) ? records : [];
+    dimensions.forEach(function (dimension) {
+      var seen = new Map();
+      list.forEach(function (record) {
+        var resolved = entry(record, dimension);
+        if (resolved && resolved.value && !seen.has(resolved.value)) {
+          seen.set(resolved.value, { value: resolved.value, label: resolved.label || resolved.value });
+        }
+      });
+      var sequence = resolveOrder(dimension);
+      result[dimension] = Array.from(seen.values()).sort(function (a, b) {
+        var ai = sequence.indexOf(a.value);
+        var bi = sequence.indexOf(b.value);
+        if (ai !== -1 || bi !== -1) {
+          if (ai === -1) return 1;
+          if (bi === -1) return -1;
+          if (ai !== bi) return ai - bi;
+        }
+        return a.label.localeCompare(b.label, undefined, { sensitivity: 'base' });
+      });
+    });
+    return result;
+  }
+
+  return { dimensions: dimensions, value: value, matches: matches, filter: filter, options: options };
+}
+
+// Drives a filter bar built from one <select> per dimension plus a reset button.
+//
+// `syncOptions` is called on EVERY render, so it short-circuits on an unchanged
+// option signature: rebuilding the <option> nodes would collapse an open
+// dropdown and drop keyboard focus every time the 4s poll lands.
+function createFilterBarController(spec) {
+  var controlIds = (spec && spec.controlIds) || {};
+  var allLabels = (spec && spec.allLabels) || {};
+  var getOptions = spec && spec.getOptions;
+  var dimensions = Object.keys(controlIds);
+  var signature = '';
+
+  function selectFor(dimension) {
+    return document.getElementById(controlIds[dimension]);
+  }
+
+  function syncOptions(records) {
+    var options = getOptions(records);
+    var controls = dimensions.map(function (dimension) {
+      return { dimension: dimension, select: selectFor(dimension) };
+    }).filter(function (control) { return control.select; });
+    if (!controls.length) return;
+    var next = JSON.stringify(options);
+    if (next === signature) return;
+    signature = next;
+    controls.forEach(function (control) {
+      var select = control.select;
+      var selected = select.value;
+      var all = document.createElement('option');
+      all.value = '';
+      all.textContent = allLabels[control.dimension];
+      var nodes = [all].concat((options[control.dimension] || []).map(function (option) {
+        var node = document.createElement('option');
+        node.value = option.value;
+        node.textContent = option.label;
+        return node;
+      }));
+      select.replaceChildren.apply(select, nodes);
+      // A selection whose option disappeared (e.g. the last record of a project
+      // was archived) falls back to "All" rather than stranding the table on a
+      // permanently empty result.
+      if (nodes.some(function (node) { return node.value === selected; })) select.value = selected;
+    });
+  }
+
+  function read() {
+    var filters = {};
+    dimensions.forEach(function (dimension) {
+      var select = selectFor(dimension);
+      filters[dimension] = select ? select.value : '';
+    });
+    return filters;
+  }
+
+  function hasActive(filters) {
+    return dimensions.some(function (dimension) { return Boolean(filters[dimension]); });
+  }
+
+  function clear() {
+    dimensions.forEach(function (dimension) {
+      var select = selectFor(dimension);
+      if (select) select.value = '';
+    });
+  }
+
+  return { syncOptions: syncOptions, read: read, hasActive: hasActive, clear: clear };
+}
+
+window.MinionsRecordFilters = {
+  text: recordFilterText,
+  key: recordFilterKey,
+  label: formatRecordFilterLabel,
+  create: createRecordFilters,
+  createBar: createFilterBarController,
+};

package/dashboard/shared/watches-source.js

@@ -3,7 +3,7 @@
 // Watches are SQL-backed: migration 007 moved `engine/watches.json` into the
 // `watches` table, and the SQL-only cutover retired the JSON mirror entirely
 // (see engine/db/index.js#_retiredJsonTargets). The engine mutates watch
-// status/_history through engine/watches-store.js — nothing writes the old
+// status/_history through engine/watches/store.js — nothing writes the old
 // file, so serving it over the static `/state/` passthrough 404s forever and
 // any UI reading it renders an empty list. `GET /api/watches` is the canonical
 // read surface.

package/dashboard/shared/welcome-popup.js

@@ -1,7 +1,7 @@
 // Shared internal-distribution welcome popup for the classic and Slim dashboards.
 //
 // W-ms1jgr95000ke749 — the first dashboard launch on an INTERNAL Minions
-// distribution (`@yemishin_microsoft/minions` et al, see engine/distribution.js)
+// distribution (`@yemishin_microsoft/minions` et al, see engine/operations/distribution.js)
 // shows a one-time modal. Public `@yemi33/minions` installs never see it: the
 // server decides via installed-package metadata and simply answers
 // `{ show: false }`, so this module renders nothing there.

package/dashboard/shared/wi-filters.js

@@ -0,0 +1,302 @@
+// Shared Work-Item filter + sort semantics. Modeled on shared/pr-filters.js so
+// the Work Items table (dashboard/js/render-work-items.js) reuses the same
+// option-derivation / filter / signature pattern the PR table uses, rather than
+// forking a divergent copy. Loaded as a dashboard/shared bundle before
+// render-work-items.js (dashboard-build.js DASHBOARD_SHARED_JS). (W-ms7kutzv003q17ad)
+var WI_FILTER_DIMENSIONS = ['status', 'type', 'project', 'agent', 'priority'];
+
+// Rank orders drive both the filter-option ordering AND the status/priority
+// sorts (so sorting is by semantic rank, not raw string compare).
+var WI_STATUS_ORDER = ['dispatched', 'pending', 'queued', 'failed', 'paused', 'done', 'decomposed', 'cancelled'];
+var WI_PRIORITY_ORDER = ['critical', 'high', 'medium', 'low'];
+
+var WI_FILTER_OPTION_ORDER = {
+  status: WI_STATUS_ORDER,
+  priority: WI_PRIORITY_ORDER,
+};
+
+function _wiFilterText(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function _wiFilterKey(value) {
+  return _wiFilterText(value).toLowerCase();
+}
+
+function _wiFormatLabel(value) {
+  var text = _wiFilterText(value).replace(/[-_]+/g, ' ');
+  return text ? text.charAt(0).toUpperCase() + text.slice(1) : '';
+}
+
+function normalizeWorkItemStatus(item) {
+  if (!item || typeof item !== 'object') return '';
+  return _wiFilterKey(item.status);
+}
+
+function normalizeWorkItemType(item) {
+  if (!item || typeof item !== 'object') return '';
+  return _wiFilterKey(item.type);
+}
+
+function normalizeWorkItemProject(item) {
+  if (!item || typeof item !== 'object') return '';
+  return _wiFilterText(item.project) || _wiFilterText(item._source);
+}
+
+function normalizeWorkItemAgent(item) {
+  if (!item || typeof item !== 'object') return '';
+  // Prefer a completed agent (multiple → first), then the assigned/dispatched
+  // agent. Mirrors the Agent column in wiRow().
+  if (Array.isArray(item.completedAgents) && item.completedAgents.length) {
+    var first = _wiFilterText(item.completedAgents[0]);
+    if (first) return first;
+  }
+  return _wiFilterText(item.dispatched_to) || _wiFilterText(item.agent);
+}
+
+function normalizeWorkItemPriority(item) {
+  if (!item || typeof item !== 'object') return '';
+  return _wiFilterKey(item.priority);
+}
+
+function _wiFilterEntry(item, dimension) {
+  var label = '';
+  var value = '';
+  if (dimension === 'status') {
+    value = normalizeWorkItemStatus(item);
+    label = _wiFormatLabel(value);
+  } else if (dimension === 'type') {
+    value = normalizeWorkItemType(item);
+    label = _wiFormatLabel(value);
+  } else if (dimension === 'project') {
+    label = normalizeWorkItemProject(item);
+    value = _wiFilterKey(label);
+  } else if (dimension === 'agent') {
+    label = normalizeWorkItemAgent(item);
+    value = _wiFilterKey(label);
+  } else if (dimension === 'priority') {
+    value = normalizeWorkItemPriority(item);
+    label = _wiFormatLabel(value);
+  }
+  return value ? { value: value, label: label || value } : null;
+}
+
+function getWorkItemFilterValue(item, dimension) {
+  var entry = _wiFilterEntry(item, dimension);
+  return entry ? entry.value : '';
+}
+
+function matchesWorkItemFilters(item, filters) {
+  filters = filters || {};
+  for (var i = 0; i < WI_FILTER_DIMENSIONS.length; i++) {
+    var dimension = WI_FILTER_DIMENSIONS[i];
+    var selected = _wiFilterKey(filters[dimension]);
+    if (selected && getWorkItemFilterValue(item, dimension) !== selected) return false;
+  }
+  return true;
+}
+
+function filterWorkItems(items, filters) {
+  if (!Array.isArray(items)) return [];
+  return items.filter(function(item) { return matchesWorkItemFilters(item, filters); });
+}
+
+function getWorkItemFilterOptions(items) {
+  var result = {};
+  var records = Array.isArray(items) ? items : [];
+  WI_FILTER_DIMENSIONS.forEach(function(dimension) {
+    var seen = new Map();
+    records.forEach(function(item) {
+      var entry = _wiFilterEntry(item, dimension);
+      if (entry && !seen.has(entry.value)) seen.set(entry.value, entry);
+    });
+    var order = WI_FILTER_OPTION_ORDER[dimension] || [];
+    result[dimension] = Array.from(seen.values()).sort(function(a, b) {
+      var ai = order.indexOf(a.value);
+      var bi = order.indexOf(b.value);
+      if (ai !== -1 || bi !== -1) {
+        if (ai === -1) return 1;
+        if (bi === -1) return -1;
+        if (ai !== bi) return ai - bi;
+      }
+      return a.label.localeCompare(b.label, undefined, { sensitivity: 'base' });
+    });
+  });
+  return result;
+}
+
+// --- Sorting -------------------------------------------------------------
+
+// Lifecycle groups: a COARSER partition of WI_STATUS_ORDER that drives the
+// default view, so the table reads active -> waiting -> needs-attention ->
+// halted -> terminal instead of interleaving statuses by raw recency
+// (W-ms9bmp8k003if9cf).
+// Every member must also appear in WI_STATUS_ORDER and the groups must be
+// disjoint (both test-enforced), so this module stays the single definition of
+// status ordering — dashboard/js/render-work-items.js no longer carries a
+// divergent copy. WI_STATUS_ORDER in turn must cover every canonical engine
+// status (engine/core/shared.js WI_STATUS), which is also test-enforced: the
+// group ordering here is direction-independent, so an unranked status would be
+// pinned behind the entire terminal tail with no way for the user to surface
+// it. A status outside every group ranks last, matching the "unknown sorts
+// last" convention _wiRank() already uses.
+var WI_LIFECYCLE_GROUPS = [
+  ['dispatched'],                       // active — an agent is working on it
+  ['pending', 'queued'],                // waiting to be dispatched
+  ['failed'],                           // needs attention — may still auto-retry
+  ['paused'],                           // halted by an operator (POST /api/plans/pause);
+                                        // non-terminal and resumable, but only a human
+                                        // can un-block it, so it trails the groups the
+                                        // engine progresses on its own
+  ['done', 'decomposed', 'cancelled'],  // terminal
+];
+
+var WI_SORT_KEYS = ['lifecycle', 'updated', 'created', 'priority', 'status', 'type'];
+var WI_SORT_DIRECTIONS = ['asc', 'desc'];
+// Default view: lifecycle groups in their inherent order, last-updated DESC
+// inside each group. Semantics of the Asc/Desc toggle under 'lifecycle': it
+// controls ONLY the within-group recency ordering. The group ordering is
+// inherent to the lifecycle and is never inverted, so terminal items can't
+// float to the top of the default view. Picking 'updated' explicitly still
+// yields pure, status-agnostic recency.
+var WI_SORT_DEFAULT = { sortBy: 'lifecycle', dir: 'desc' };
+
+// Sort keys whose primary comparator is coarse-grained (many items share one
+// rank). These tie-break by last-updated DESC before falling through to the id
+// tie-break, so a status group reads newest-first instead of id-first.
+// 'lifecycle' is absent by design: recency is already its within-group primary.
+var WI_RECENCY_TIEBREAK_KEYS = ['status'];
+
+function _wiTimeMs(value) {
+  if (value == null || value === '') return null;
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  var parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+// Canonical last-updated timestamp. Prefer the real updatedAt surfaced by the
+// store, then completedAt, dispatched_at, created (legacy fallback only — never
+// faked from created when a real updatedAt exists). Returns ms epoch or null.
+function workItemLastUpdatedMs(item) {
+  if (!item || typeof item !== 'object') return null;
+  return _wiTimeMs(item.updatedAt)
+    ?? _wiTimeMs(item.updated_at)
+    ?? _wiTimeMs(item.completedAt)
+    ?? _wiTimeMs(item.completed_at)
+    ?? _wiTimeMs(item.dispatched_at)
+    ?? _wiTimeMs(item.created)
+    ?? _wiTimeMs(item.created_at);
+}
+
+function _wiCreatedMs(item) {
+  if (!item || typeof item !== 'object') return null;
+  return _wiTimeMs(item.created) ?? _wiTimeMs(item.created_at);
+}
+
+function _wiRank(order, value) {
+  var i = order.indexOf(_wiFilterKey(value));
+  return i === -1 ? order.length : i;
+}
+
+// Lifecycle group index for an item (0 = active ... N = unknown/last).
+function workItemLifecycleRank(item) {
+  var status = normalizeWorkItemStatus(item);
+  for (var i = 0; i < WI_LIFECYCLE_GROUPS.length; i++) {
+    if (WI_LIFECYCLE_GROUPS[i].indexOf(status) !== -1) return i;
+  }
+  return WI_LIFECYCLE_GROUPS.length;
+}
+
+// Grouping whose ordering is INHERENT rather than user-chosen, and therefore
+// direction-independent. Returns 0 for sort keys that have no fixed grouping.
+function _wiFixedGroupCompare(a, b, sortBy) {
+  if (sortBy !== 'lifecycle') return 0;
+  return workItemLifecycleRank(a) - workItemLifecycleRank(b);
+}
+
+// Newest-first recency comparator used as a tie-break for coarse sort keys.
+// Missing timestamps sort last (treated as oldest), mirroring _wiCompare.
+function _wiRecencyDesc(a, b) {
+  var av = workItemLastUpdatedMs(a);
+  var bv = workItemLastUpdatedMs(b);
+  if (av == null && bv == null) return 0;
+  if (av == null) return 1;
+  if (bv == null) return -1;
+  return bv - av;
+}
+
+function _wiCompare(a, b, sortBy) {
+  if (sortBy === 'priority') {
+    return _wiRank(WI_PRIORITY_ORDER, a.priority) - _wiRank(WI_PRIORITY_ORDER, b.priority);
+  }
+  if (sortBy === 'status') {
+    return _wiRank(WI_STATUS_ORDER, a.status) - _wiRank(WI_STATUS_ORDER, b.status);
+  }
+  if (sortBy === 'type') {
+    return _wiFilterKey(a.type).localeCompare(_wiFilterKey(b.type), undefined, { sensitivity: 'base' });
+  }
+  var av, bv;
+  if (sortBy === 'created') {
+    av = _wiCreatedMs(a); bv = _wiCreatedMs(b);
+  } else {
+    // 'lifecycle' (within-group ordering, after _wiFixedGroupCompare has
+    // separated the groups), 'updated' (default) and any unknown key fall
+    // through to last-updated.
+    av = workItemLastUpdatedMs(a); bv = workItemLastUpdatedMs(b);
+  }
+  // Missing timestamps sort last in ascending order (i.e. treated as oldest).
+  if (av == null && bv == null) return 0;
+  if (av == null) return -1;
+  if (bv == null) return 1;
+  return av - bv;
+}
+
+// Stable sort: applies any fixed (direction-independent) grouping first, then
+// the primary comparator ascending, then reverses for desc, with a recency and
+// finally an id tie-break so equal keys keep a deterministic order.
+function sortWorkItems(items, sort) {
+  if (!Array.isArray(items)) return [];
+  var sortBy = sort && WI_SORT_KEYS.indexOf(sort.sortBy) !== -1 ? sort.sortBy : WI_SORT_DEFAULT.sortBy;
+  var dir = sort && WI_SORT_DIRECTIONS.indexOf(sort.dir) !== -1 ? sort.dir : WI_SORT_DEFAULT.dir;
+  var mult = dir === 'asc' ? 1 : -1;
+  var recencyTieBreak = WI_RECENCY_TIEBREAK_KEYS.indexOf(sortBy) !== -1;
+  var withIdx = items.map(function(item, idx) { return { item: item, idx: idx }; });
+  withIdx.sort(function(a, b) {
+    // Inherent group ordering — never multiplied by `mult`, so toggling the
+    // direction cannot float terminal work above active work.
+    var group = _wiFixedGroupCompare(a.item, b.item, sortBy);
+    if (group !== 0) return group;
+    var primary = _wiCompare(a.item, b.item, sortBy);
+    if (primary !== 0) return primary * mult;
+    // Coarse keys tie-break by recency (newest first, direction-independent —
+    // same contract as the id tie-break) so a whole status group doesn't read
+    // in id order.
+    if (recencyTieBreak) {
+      var recency = _wiRecencyDesc(a.item, b.item);
+      if (recency !== 0) return recency;
+    }
+    // Deterministic tie-break by id (ascending, direction-independent) so ties
+    // are stable regardless of the primary direction; fall back to input index.
+    var ida = _wiFilterText(a.item && a.item.id);
+    var idb = _wiFilterText(b.item && b.item.id);
+    if (ida !== idb) return ida < idb ? -1 : 1;
+    return a.idx - b.idx;
+  });
+  return withIdx.map(function(entry) { return entry.item; });
+}
+
+window.MinionsWorkItemFilters = {
+  dimensions: WI_FILTER_DIMENSIONS,
+  value: getWorkItemFilterValue,
+  matches: matchesWorkItemFilters,
+  filter: filterWorkItems,
+  options: getWorkItemFilterOptions,
+  sort: sortWorkItems,
+  lastUpdatedMs: workItemLastUpdatedMs,
+  lifecycleRank: workItemLifecycleRank,
+  sortKeys: WI_SORT_KEYS,
+  sortDefault: WI_SORT_DEFAULT,
+  statusOrder: WI_STATUS_ORDER,
+  lifecycleGroups: WI_LIFECYCLE_GROUPS,
+  priorityOrder: WI_PRIORITY_ORDER,
+};