npm - @atolis-hq/wake - Versions diffs - 0.2.21 → 0.2.23 - Mend

@atolis-hq/wake 0.2.21 → 0.2.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/src/adapters/http/ui-assets.js +304 -17
package/dist/src/adapters/http/ui-data.js +514 -0
package/dist/src/adapters/http/ui-server.js +11 -1
package/dist/src/core/policy-engine.js +13 -3
package/dist/src/core/projection-updater.js +9 -0
package/dist/src/domain/schema.js +6 -0
package/dist/src/version.js +1 -1
package/package.json +1 -1

package/dist/src/adapters/http/ui-assets.js CHANGED Viewed

@@ -85,6 +85,15 @@ export const indexHtml = `<!DOCTYPE html>
   .tile { background: #1a1d23; border-radius: 10px; padding: 0.6rem 0.9rem; min-width: 120px; }
   .tile .n { font-size: 1.3rem; font-weight: 700; }
   .tile .l { color: #9aa2ad; font-size: 0.72rem; text-transform: uppercase; }
+  .toolbar { display: flex; align-items: center; gap: 0.75rem; flex-wrap: wrap; margin-bottom: 1rem; }
+  .toolbar label { display: inline-flex; align-items: center; gap: 0.35rem; color: #9aa2ad; font-size: 0.8rem; }
+  select { background: #1a1d23; border: 1px solid #2c313a; color: #e8e8e8; padding: 0.3rem 0.5rem; border-radius: 6px; font-size: 0.8rem; }
+  select:focus { outline: none; border-color: var(--accent); box-shadow: 0 0 0 3px rgba(45, 212, 191, 0.15); }
+  .metric-bar { width: 160px; height: 0.5rem; background: #101216; border-radius: 999px; overflow: hidden; }
+  .metric-bar-fill { height: 100%; background: var(--accent); border-radius: 999px; }
+  .stacked-bar { display: flex; width: min(520px, 45vw); min-width: 220px; height: 0.75rem; background: #101216; border-radius: 999px; overflow: hidden; }
+  .stacked-segment { height: 100%; min-width: 1px; }
+  .metric-table-value { display: flex; align-items: center; gap: 0.55rem; }
   .amber { color: #ffcf7f; }
   .red { color: #ff8f7f; }
   .ok { color: #7fe3a3; }
@@ -114,6 +123,7 @@ export const indexHtml = `<!DOCTYPE html>
   <button data-view="board" class="active">Board</button>
   <button data-view="activity">Activity</button>
   <button data-view="runs">Runs</button>
+  <button data-view="analytics">Analytics</button>
   <button data-view="config">Config</button>
   <button data-view="health">Health</button>
 </nav>
@@ -132,9 +142,32 @@ export const indexHtml = `<!DOCTYPE html>
 const API = '/api/v1';
 const CONDITIONS = ['needs-human', 'active', 'ready', 'waiting', 'stalled', 'finished'];
 let currentView = 'board';
+let analyticsWindow = '7d';
+let analyticsMetric = 'runs-over-time';
+let activeViewRequest = null;
+let activeViewRequestId = 0;
-async function getJson(path) {
-  const res = await fetch(API + path);
+const METRIC_OPTIONS = [
+  ['runs-over-time', 'Runs over time'],
+  ['runs-by-status-over-time', 'Runs by status over time'],
+  ['runs-by-status', 'Runs by status'],
+  ['runs-by-action', 'Runs by action/stage'],
+  ['runs-by-repo', 'Runs by repo'],
+  ['runs-by-runner', 'Runs by runner'],
+  ['runs-by-model', 'Runs by model'],
+  ['runs-by-tier', 'Runs by tier'],
+  ['tokens-over-time', 'Tokens over time'],
+  ['tokens-by-action', 'Tokens by action/stage'],
+  ['tokens-by-runner', 'Tokens by runner'],
+  ['tokens-by-model', 'Tokens by model'],
+  ['duration-by-action', 'Duration by action/stage'],
+  ['duration-over-time', 'Duration over time'],
+  ['work-items-over-time', 'Work items completed over time'],
+  ['work-item-durations', 'Work item e2e duration'],
+];
+async function getJson(path, signal) {
+  const res = await fetch(API + path, signal ? { signal } : undefined);
   if (!res.ok) throw new Error(path + ' -> ' + res.status);
   return res.json();
 }
@@ -167,6 +200,14 @@ function el(tag, attrs, children) {
   return node;
 }
+function isActiveRequest(requestId) {
+  return activeViewRequest && activeViewRequest.id === requestId;
+}
+function loadingNode(label) {
+  return el('p', { class: 'meta', text: 'Loading ' + label + '...' });
+}
 async function renderStatusBar() {
   try {
     const status = await getJson('/status');
@@ -203,8 +244,9 @@ async function forceTickNow() {
   }
 }
-async function renderBoard() {
-  const board = await getJson('/board');
+async function renderBoard(context) {
+  const board = await getJson('/board', context.signal);
+  if (!isActiveRequest(context.requestId)) return;
   const main = document.getElementById('main');
   main.innerHTML = '';
   const columns = el('div', { class: 'columns' }, CONDITIONS.map((cond) => {
@@ -388,8 +430,9 @@ function renderTranscripts(transcripts) {
   return root;
 }
-async function renderActivity() {
-  const events = await getJson('/events?limit=200');
+async function renderActivity(context) {
+  const events = await getJson('/events?limit=200', context.signal);
+  if (!isActiveRequest(context.requestId)) return;
   const main = document.getElementById('main');
   main.innerHTML = '';
   const table = el('table', {}, [
@@ -415,8 +458,239 @@ function fmtTokens(tokenUsage) {
   return total >= 1000 ? (total / 1000).toFixed(1) + 'k' : String(total);
 }
-async function renderRuns() {
-  const runs = await getJson('/runs');
+function fmtNumber(value) {
+  return Number(value || 0).toLocaleString();
+}
+function fmtDuration(ms) {
+  return ms === undefined || ms === null ? '' : fmtMs(ms);
+}
+function metricBar(value, max) {
+  const pct = max > 0 ? Math.max(2, Math.round((value / max) * 100)) : 0;
+  return el('div', { class: 'metric-bar' }, [
+    el('div', { class: 'metric-bar-fill', style: 'width:' + pct + '%' }),
+  ]);
+}
+function stackedBar(segments) {
+  const total = segments.reduce((sum, segment) => sum + segment.value, 0);
+  return el('div', { class: 'stacked-bar' }, segments.filter((segment) => segment.value > 0).map((segment) =>
+    el('div', {
+      class: 'stacked-segment',
+      title: segment.label + ': ' + fmtNumber(segment.value),
+      style: 'width:' + ((segment.value / total) * 100).toFixed(2) + '%;background:' + segment.color,
+    }),
+  ));
+}
+function selectBox(value, options, onChange) {
+  return el('select', { onchange: (event) => onChange(event.target.value) }, options.map((option) =>
+    el('option', {
+      value: option[0],
+      text: option[1],
+      ...(option[0] === value ? { selected: 'selected' } : {}),
+    }),
+  ));
+}
+function metricValueCell(value, max, format) {
+  return el('td', {}, [
+    el('div', { class: 'metric-table-value' }, [
+      el('span', { text: format(value) }),
+      metricBar(value, max),
+    ]),
+  ]);
+}
+function renderCountTable(rows, label) {
+  if (rows.length === 0) return el('p', { class: 'meta', text: 'No data for this window.' });
+  const max = Math.max(...rows.map((row) => row.count));
+  return el('table', {}, [
+    el('tr', {}, [el('th', { text: label }), el('th', { text: 'runs' })]),
+    ...rows.map((row) => el('tr', {}, [
+      el('td', { text: row.key }),
+      metricValueCell(row.count, max, fmtNumber),
+    ])),
+  ]);
+}
+function renderTokenTable(rows, label) {
+  if (rows.length === 0) return el('p', { class: 'meta', text: 'No data for this window.' });
+  const max = Math.max(...rows.map((row) => row.tokens));
+  return el('table', {}, [
+    el('tr', {}, [
+      el('th', { text: label }),
+      el('th', { text: 'tokens' }),
+      el('th', { text: 'avg/run' }),
+      el('th', { text: 'cost' }),
+      el('th', { text: 'avg cost/run' }),
+      el('th', { text: 'runs' }),
+    ]),
+    ...rows.map((row) => el('tr', {}, [
+      el('td', { text: row.key }),
+      metricValueCell(row.tokens, max, fmtNumber),
+      el('td', { text: fmtNumber(row.averageTokens || 0) }),
+      el('td', { text: fmtCost(row.costUsd) }),
+      el('td', { text: fmtCost(row.averageCostUsd) }),
+      el('td', { text: fmtNumber(row.count || 0) }),
+    ])),
+  ]);
+}
+function renderDurationTable(rows, label) {
+  if (rows.length === 0) return el('p', { class: 'meta', text: 'No data for this window.' });
+  const max = Math.max(...rows.map((row) => row.totalMs || row.medianMs));
+  return el('table', {}, [
+    el('tr', {}, [
+      el('th', { text: label }),
+      el('th', { text: 'total' }),
+      el('th', { text: 'median' }),
+      el('th', { text: 'average' }),
+      el('th', { text: 'runs' }),
+    ]),
+    ...rows.map((row) => el('tr', {}, [
+      el('td', { text: row.key || row.label }),
+      metricValueCell(row.totalMs || 0, max, fmtDuration),
+      el('td', { text: fmtDuration(row.medianMs) }),
+      el('td', { text: fmtDuration(row.averageMs) }),
+      el('td', { text: fmtNumber(row.count) }),
+    ])),
+  ]);
+}
+function renderRunsOverTime(rows) {
+  return el('table', {}, [
+    el('tr', {}, [el('th', { text: 'bucket' }), el('th', { text: 'runs' }), el('th', { text: 'status split' })]),
+    ...rows.map((row) => el('tr', {}, [
+      el('td', { text: row.label }),
+      el('td', { text: fmtNumber(row.total) }),
+      el('td', {}, [stackedBar([
+        { label: 'completed', value: row.completed, color: '#7fe3a3' },
+        { label: 'blocked', value: row.blocked, color: '#ffcf7f' },
+        { label: 'awaiting approval', value: row.awaitingApproval, color: '#7fb3ff' },
+        { label: 'failed', value: row.failed, color: '#ff8f7f' },
+        { label: 'other', value: row.other, color: '#9aa2ad' },
+      ])]),
+    ])),
+  ]);
+}
+function renderRunsByStatusOverTime(rows) {
+  return el('table', {}, [
+    el('tr', {}, [
+      el('th', { text: 'bucket' }),
+      el('th', { text: 'completed' }),
+      el('th', { text: 'blocked' }),
+      el('th', { text: 'awaiting approval' }),
+      el('th', { text: 'failed' }),
+      el('th', { text: 'other' }),
+      el('th', { text: 'total' }),
+    ]),
+    ...rows.map((row) => el('tr', {}, [
+      el('td', { text: row.label }),
+      el('td', { text: fmtNumber(row.completed) }),
+      el('td', { text: fmtNumber(row.blocked) }),
+      el('td', { text: fmtNumber(row.awaitingApproval) }),
+      el('td', { text: fmtNumber(row.failed) }),
+      el('td', { text: fmtNumber(row.other) }),
+      el('td', { text: fmtNumber(row.total) }),
+    ])),
+  ]);
+}
+function renderTokensOverTime(rows) {
+  return el('table', {}, [
+    el('tr', {}, [el('th', { text: 'bucket' }), el('th', { text: 'tokens' }), el('th', { text: 'token split' }), el('th', { text: 'cost' })]),
+    ...rows.map((row) => el('tr', {}, [
+      el('td', { text: row.label }),
+      el('td', { text: fmtNumber(row.tokens) }),
+      el('td', {}, [stackedBar([
+        { label: 'input', value: row.inputTokens, color: '#7fb3ff' },
+        { label: 'output', value: row.outputTokens, color: '#7fe3a3' },
+        { label: 'cache creation', value: row.cacheCreationInputTokens, color: '#c79bff' },
+        { label: 'cache read', value: row.cacheReadInputTokens, color: '#ffcf7f' },
+      ])]),
+      el('td', { text: fmtCost(row.costUsd) }),
+    ])),
+  ]);
+}
+function renderWorkItemsOverTime(rows) {
+  const max = Math.max(0, ...rows.map((row) => row.completed));
+  return el('table', {}, [
+    el('tr', {}, [el('th', { text: 'bucket' }), el('th', { text: 'completed' })]),
+    ...rows.map((row) => el('tr', {}, [
+      el('td', { text: row.label }),
+      metricValueCell(row.completed, max, fmtNumber),
+    ])),
+  ]);
+}
+function renderWorkItemDurations(rows) {
+  if (rows.length === 0) return el('p', { class: 'meta', text: 'No completed work items for this window.' });
+  const max = Math.max(...rows.map((row) => row.durationMs));
+  return el('table', {}, [
+    el('tr', {}, ['work item', 'duration', 'completed'].map((h) => el('th', { text: h }))),
+    ...rows.map((row) => el('tr', {}, [
+      el('td', { text: row.repo + '#' + row.issueNumber }),
+      metricValueCell(row.durationMs, max, fmtDuration),
+      el('td', { text: row.completedAt }),
+    ])),
+  ]);
+}
+function renderMetricDetail(detail) {
+  if (detail.kind === 'runs-over-time') return renderRunsOverTime(detail.rows);
+  if (detail.kind === 'runs-by-status-over-time') return renderRunsByStatusOverTime(detail.rows);
+  if (detail.kind === 'run-counts') return renderCountTable(detail.rows, detail.group);
+  if (detail.kind === 'tokens-over-time') return renderTokensOverTime(detail.rows);
+  if (detail.kind === 'token-counts') return renderTokenTable(detail.rows, detail.group);
+  if (detail.kind === 'durations') return renderDurationTable(detail.rows, detail.group);
+  if (detail.kind === 'duration-over-time') return renderDurationTable(detail.rows, 'bucket');
+  if (detail.kind === 'work-items-over-time') return renderWorkItemsOverTime(detail.rows);
+  if (detail.kind === 'work-item-durations') return renderWorkItemDurations(detail.rows);
+  return el('p', { class: 'meta', text: 'Unsupported metric.' });
+}
+async function renderAnalytics(context) {
+  const metrics = await getJson('/metrics?window=' + encodeURIComponent(analyticsWindow) + '&metric=' + encodeURIComponent(analyticsMetric), context.signal);
+  if (!isActiveRequest(context.requestId)) return;
+  const main = document.getElementById('main');
+  main.innerHTML = '';
+  main.appendChild(el('div', { class: 'toolbar' }, [
+    el('label', {}, [
+      document.createTextNode('Window'),
+      selectBox(analyticsWindow, [['1d', '1d'], ['3d', '3d'], ['5d', '5d'], ['7d', '7d']], (value) => {
+        analyticsWindow = value;
+        switchView('analytics');
+      }),
+    ]),
+    el('label', {}, [
+      document.createTextNode('Metric'),
+      selectBox(analyticsMetric, METRIC_OPTIONS, (value) => {
+        analyticsMetric = value;
+        switchView('analytics');
+      }),
+    ]),
+  ]));
+  main.appendChild(el('div', { class: 'tiles' }, [
+    tile('Runs', fmtNumber(metrics.summary.totalRuns)),
+    tile('Completed', fmtNumber(metrics.summary.completedRuns)),
+    tile('Blocked/approval', fmtNumber(metrics.summary.blockedRuns + metrics.summary.awaitingApprovalRuns)),
+    tile('Failed', fmtNumber(metrics.summary.failedRuns)),
+    tile('Tokens', fmtNumber(metrics.summary.totalTokens)),
+    tile('Cost', fmtCost(metrics.summary.totalCostUsd)),
+    tile('Median run', fmtDuration(metrics.summary.medianRunDurationMs) || '—'),
+    tile('Work done', fmtNumber(metrics.summary.completedWorkItems)),
+    tile('Median e2e', fmtDuration(metrics.summary.medianWorkItemDurationMs) || '—'),
+  ]));
+  main.appendChild(renderMetricDetail(metrics.detail));
+}
+async function renderRuns(context) {
+  const runs = await getJson('/runs', context.signal);
+  if (!isActiveRequest(context.requestId)) return;
   const main = document.getElementById('main');
   main.innerHTML = '';
   const table = el('table', {}, [
@@ -431,8 +705,9 @@ async function renderRuns() {
   main.appendChild(table);
 }
-async function renderConfig() {
-  const data = await getJson('/config');
+async function renderConfig(context) {
+  const data = await getJson('/config', context.signal);
+  if (!isActiveRequest(context.requestId)) return;
   const main = document.getElementById('main');
   main.innerHTML = '';
   main.appendChild(el('h3', { text: 'Routing table' }));
@@ -449,7 +724,7 @@ async function renderConfig() {
           btn.textContent = 'Unpausing…';
           try {
             await postJson('/runners/' + encodeURIComponent(c.runnerName) + '/unpause');
-            await renderConfig();
+            switchView('config');
           } catch (err) {
             btn.disabled = false;
             btn.textContent = 'Unpause';
@@ -467,8 +742,9 @@ async function renderConfig() {
   main.appendChild(el('pre', { text: JSON.stringify(data.config, null, 2) }));
 }
-async function renderHealth() {
-  const health = await getJson('/health');
+async function renderHealth(context) {
+  const health = await getJson('/health', context.signal);
+  if (!isActiveRequest(context.requestId)) return;
   const main = document.getElementById('main');
   main.innerHTML = '';
   const runnerNames = Object.keys(health.pause.runnerHealth || {});
@@ -512,14 +788,25 @@ function tile(label, value) {
   return el('div', { class: 'tile' }, [el('div', { class: 'n', text: value }), el('div', { class: 'l', text: label })]);
 }
-const renderers = { board: renderBoard, activity: renderActivity, runs: renderRuns, config: renderConfig, health: renderHealth };
+const renderers = { board: renderBoard, activity: renderActivity, runs: renderRuns, analytics: renderAnalytics, config: renderConfig, health: renderHealth };
-function switchView(view) {
+function switchView(view, options) {
+  if (activeViewRequest) activeViewRequest.controller.abort();
+  const controller = new AbortController();
+  const requestId = ++activeViewRequestId;
+  activeViewRequest = { id: requestId, controller };
   currentView = view;
   for (const btn of document.querySelectorAll('nav button')) {
     btn.classList.toggle('active', btn.dataset.view === view);
   }
-  renderers[view]();
+  const main = document.getElementById('main');
+  if (!options || options.showLoading !== false) {
+    main.replaceChildren(loadingNode(view));
+  }
+  renderers[view]({ signal: controller.signal, requestId }).catch((err) => {
+    if (err.name === 'AbortError' || !isActiveRequest(requestId)) return;
+    main.replaceChildren(el('p', { class: 'meta red', text: 'Failed to load ' + view + ': ' + err.message }));
+  });
 }
 for (const btn of document.querySelectorAll('nav button')) {
@@ -539,7 +826,7 @@ renderStatusBar();
 switchView('board');
 setInterval(() => {
   renderStatusBar();
-  renderers[currentView]();
+  switchView(currentView, { showLoading: false });
 }, 7000);
 </script>
 </body>

package/dist/src/adapters/http/ui-data.js CHANGED Viewed

@@ -364,6 +364,520 @@ export async function buildRuns(input) {
         .filter((run) => input.repo === undefined || run.repo === input.repo)
         .sort((left, right) => right.startedAt.localeCompare(left.startedAt));
 }
+const metricsWindows = new Set(['1d', '3d', '5d', '7d']);
+const metricsMetrics = new Set([
+    'runs-over-time',
+    'runs-by-status-over-time',
+    'runs-by-status',
+    'runs-by-action',
+    'runs-by-repo',
+    'runs-by-runner',
+    'runs-by-model',
+    'runs-by-tier',
+    'tokens-over-time',
+    'tokens-by-action',
+    'tokens-by-runner',
+    'tokens-by-model',
+    'duration-by-action',
+    'duration-over-time',
+    'work-items-over-time',
+    'work-item-durations',
+]);
+function parseMetricsWindow(value) {
+    return metricsWindows.has(value) ? value : '7d';
+}
+function parseMetricsMetric(value) {
+    return metricsMetrics.has(value) ? value : 'runs-over-time';
+}
+function utcDayStartMs(date) {
+    return Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+}
+function monthDayLabel(date) {
+    const months = [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'May',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec',
+    ];
+    return `${months[date.getUTCMonth()]} ${date.getUTCDate()}`;
+}
+function pad2(value) {
+    return String(value).padStart(2, '0');
+}
+function createTimeBuckets(window, now) {
+    const dayMs = 24 * 60 * 60 * 1000;
+    const hourMs = 60 * 60 * 1000;
+    const todayStart = utcDayStartMs(now);
+    if (window === '1d') {
+        return Array.from({ length: 24 }, (_, hour) => {
+            const startMs = todayStart + hour * hourMs;
+            const day = new Date(startMs);
+            return {
+                bucket: `${day.toISOString().slice(0, 10)}T${pad2(hour)}`,
+                label: `${pad2(hour)}:00`,
+                startMs,
+                endMs: startMs + hourMs,
+            };
+        });
+    }
+    if (window === '3d') {
+        const start = todayStart - 2 * dayMs;
+        return Array.from({ length: 12 }, (_, index) => {
+            const startMs = start + index * 6 * hourMs;
+            const day = new Date(startMs);
+            const hour = day.getUTCHours();
+            return {
+                bucket: `${day.toISOString().slice(0, 10)}T${pad2(hour)}`,
+                label: `${monthDayLabel(day)} ${pad2(hour)}:00`,
+                startMs,
+                endMs: startMs + 6 * hourMs,
+            };
+        });
+    }
+    const days = window === '5d' ? 5 : 7;
+    const start = todayStart - (days - 1) * dayMs;
+    return Array.from({ length: days }, (_, index) => {
+        const startMs = start + index * dayMs;
+        const day = new Date(startMs);
+        return {
+            bucket: day.toISOString().slice(0, 10),
+            label: monthDayLabel(day),
+            startMs,
+            endMs: startMs + dayMs,
+        };
+    });
+}
+function inMetricsWindow(timestamp, buckets) {
+    const at = Date.parse(timestamp);
+    const first = buckets[0];
+    const last = buckets.at(-1);
+    return (Number.isFinite(at) &&
+        first !== undefined &&
+        last !== undefined &&
+        at >= first.startMs &&
+        at < last.endMs);
+}
+function findBucket(timestamp, buckets) {
+    const at = Date.parse(timestamp);
+    if (!Number.isFinite(at)) {
+        return undefined;
+    }
+    return buckets.find((bucket) => at >= bucket.startMs && at < bucket.endMs);
+}
+async function listRunsForBuckets(stateStore, buckets) {
+    const dates = [...new Set(buckets.map((bucket) => bucket.bucket.slice(0, 10)))];
+    const runsById = new Map();
+    const recordsByDate = await Promise.all(dates.map((date) => stateStore.listRunRecordsForDate(date)));
+    for (const records of recordsByDate) {
+        for (const record of records) {
+            runsById.set(record.runId, record);
+        }
+    }
+    return [...runsById.values()].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+}
+function runTokenTotal(run) {
+    const usage = run.tokenUsage;
+    if (usage === undefined) {
+        return 0;
+    }
+    return (usage.inputTokens +
+        usage.outputTokens +
+        (usage.cacheCreationInputTokens ?? 0) +
+        (usage.cacheReadInputTokens ?? 0));
+}
+function median(values) {
+    if (values.length === 0) {
+        return undefined;
+    }
+    const sorted = values.slice().sort((left, right) => left - right);
+    const middle = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 1) {
+        return sorted[middle];
+    }
+    return ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2;
+}
+function average(values) {
+    return values.length === 0
+        ? 0
+        : values.reduce((total, value) => total + value, 0) / values.length;
+}
+function runDurationMs(run) {
+    if (run.finishedAt === undefined) {
+        return undefined;
+    }
+    const started = Date.parse(run.startedAt);
+    const finished = Date.parse(run.finishedAt);
+    if (!Number.isFinite(started) || !Number.isFinite(finished) || finished < started) {
+        return undefined;
+    }
+    return finished - started;
+}
+function groupCount(entries, keyFor) {
+    const counts = new Map();
+    for (const entry of entries) {
+        const key = keyFor(entry);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return [...counts.entries()]
+        .map(([key, count]) => ({ key, count }))
+        .sort((left, right) => right.count - left.count || left.key.localeCompare(right.key));
+}
+function groupTokens(runs, keyFor) {
+    const groups = new Map();
+    for (const run of runs) {
+        const key = keyFor(run);
+        const existing = groups.get(key) ?? { count: 0, tokens: 0, costUsd: 0 };
+        existing.count += 1;
+        existing.tokens += runTokenTotal(run);
+        existing.costUsd += run.tokenUsage?.costUsd ?? 0;
+        groups.set(key, existing);
+    }
+    return [...groups.entries()]
+        .map(([key, value]) => ({
+        key,
+        ...value,
+        averageTokens: value.count === 0 ? 0 : value.tokens / value.count,
+        averageCostUsd: value.count === 0 ? 0 : value.costUsd / value.count,
+    }))
+        .sort((left, right) => right.tokens - left.tokens || left.key.localeCompare(right.key));
+}
+function groupDurations(runs, keyFor) {
+    const groups = new Map();
+    for (const run of runs) {
+        const duration = runDurationMs(run);
+        if (duration === undefined) {
+            continue;
+        }
+        const key = keyFor(run);
+        groups.set(key, [...(groups.get(key) ?? []), duration]);
+    }
+    return [...groups.entries()]
+        .map(([key, values]) => ({
+        key,
+        count: values.length,
+        totalMs: values.reduce((total, value) => total + value, 0),
+        averageMs: average(values),
+        medianMs: median(values) ?? 0,
+    }))
+        .sort((left, right) => right.medianMs - left.medianMs || left.key.localeCompare(right.key));
+}
+function runnerKey(run) {
+    return run.routing?.runnerName ?? 'unknown';
+}
+function tierKey(run) {
+    return run.routing?.tier ?? 'unknown';
+}
+function modelKey(run, config) {
+    const runnerName = run.routing?.runnerName;
+    if (runnerName === undefined) {
+        return 'unknown';
+    }
+    const runner = config.runners[runnerName];
+    if (runner === undefined || runner.kind === 'fake') {
+        return 'unknown';
+    }
+    return runner.models[run.action] ?? runner.models.default ?? runner.model;
+}
+function completedAtForItem(item) {
+    const doneEntry = item.wake.stageHistory.find((entry) => entry.stage === 'done');
+    if (doneEntry !== undefined) {
+        return doneEntry.changedAt;
+    }
+    if (item.issue.state === 'closed') {
+        return item.issue.updatedAt;
+    }
+    if (isTerminalStage(item.wake.stage)) {
+        return item.wake.stageHistory.at(-1)?.changedAt ?? item.issue.updatedAt;
+    }
+    return undefined;
+}
+function startedAtForItem(item) {
+    return item.issue.createdAt ?? item.wake.stageHistory[0]?.changedAt;
+}
+function completedWorkItemDurations(items, buckets) {
+    const rows = [];
+    for (const item of items) {
+        const completedAt = completedAtForItem(item);
+        const startedAt = startedAtForItem(item);
+        if (completedAt === undefined ||
+            startedAt === undefined ||
+            !inMetricsWindow(completedAt, buckets)) {
+            continue;
+        }
+        const completedMs = Date.parse(completedAt);
+        const startedMs = Date.parse(startedAt);
+        if (!Number.isFinite(completedMs) || !Number.isFinite(startedMs) || completedMs < startedMs) {
+            continue;
+        }
+        rows.push({
+            key: item.workItemKey,
+            repo: item.issue.repo,
+            issueNumber: item.issue.number,
+            durationMs: completedMs - startedMs,
+            completedAt,
+        });
+    }
+    return rows.sort((left, right) => right.completedAt.localeCompare(left.completedAt));
+}
+function buildMetricsSummary(runs, workItemDurations) {
+    const runDurations = runs
+        .map((run) => runDurationMs(run))
+        .filter((duration) => duration !== undefined);
+    return {
+        totalRuns: runs.length,
+        completedRuns: runs.filter((run) => run.status === 'completed').length,
+        blockedRuns: runs.filter((run) => run.status === 'blocked').length,
+        awaitingApprovalRuns: runs.filter((run) => run.status === 'awaiting-approval').length,
+        failedRuns: runs.filter((run) => run.status === 'failed').length,
+        totalTokens: runs.reduce((total, run) => total + runTokenTotal(run), 0),
+        totalCostUsd: runs.reduce((total, run) => total + (run.tokenUsage?.costUsd ?? 0), 0),
+        medianRunDurationMs: median(runDurations),
+        completedWorkItems: workItemDurations.length,
+        medianWorkItemDurationMs: median(workItemDurations.map((row) => row.durationMs)),
+    };
+}
+export async function buildMetrics(input) {
+    const window = parseMetricsWindow(input.window);
+    const metric = parseMetricsMetric(input.metric);
+    const buckets = createTimeBuckets(window, input.now);
+    const [allRuns, items] = await Promise.all([
+        listRunsForBuckets(input.stateStore, buckets),
+        input.stateStore.listIssueStates(),
+    ]);
+    const runs = allRuns.filter((run) => inMetricsWindow(run.startedAt, buckets));
+    const workItemDurations = completedWorkItemDurations(items, buckets);
+    const summary = buildMetricsSummary(runs, workItemDurations);
+    const runCountsForBucket = (bucket) => {
+        const bucketRuns = runs.filter((run) => findBucket(run.startedAt, buckets)?.bucket === bucket.bucket);
+        return {
+            bucket: bucket.bucket,
+            label: bucket.label,
+            total: bucketRuns.length,
+            completed: bucketRuns.filter((run) => run.status === 'completed').length,
+            blocked: bucketRuns.filter((run) => run.status === 'blocked').length,
+            awaitingApproval: bucketRuns.filter((run) => run.status === 'awaiting-approval').length,
+            failed: bucketRuns.filter((run) => run.status === 'failed').length,
+            other: bucketRuns.filter((run) => !['completed', 'blocked', 'awaiting-approval', 'failed'].includes(run.status)).length,
+        };
+    };
+    const tokenCountsForBucket = (bucket) => {
+        const bucketRuns = runs.filter((run) => findBucket(run.startedAt, buckets)?.bucket === bucket.bucket);
+        return {
+            bucket: bucket.bucket,
+            label: bucket.label,
+            tokens: bucketRuns.reduce((total, run) => total + runTokenTotal(run), 0),
+            inputTokens: bucketRuns.reduce((total, run) => total + (run.tokenUsage?.inputTokens ?? 0), 0),
+            outputTokens: bucketRuns.reduce((total, run) => total + (run.tokenUsage?.outputTokens ?? 0), 0),
+            cacheCreationInputTokens: bucketRuns.reduce((total, run) => total + (run.tokenUsage?.cacheCreationInputTokens ?? 0), 0),
+            cacheReadInputTokens: bucketRuns.reduce((total, run) => total + (run.tokenUsage?.cacheReadInputTokens ?? 0), 0),
+            costUsd: bucketRuns.reduce((total, run) => total + (run.tokenUsage?.costUsd ?? 0), 0),
+        };
+    };
+    switch (metric) {
+        case 'runs-by-status':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'run-counts',
+                    group: 'status',
+                    rows: groupCount(runs, (run) => run.status),
+                },
+            };
+        case 'runs-by-status-over-time':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'runs-by-status-over-time',
+                    rows: buckets.map(runCountsForBucket),
+                },
+            };
+        case 'runs-by-action':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'run-counts',
+                    group: 'action',
+                    rows: groupCount(runs, (run) => run.action),
+                },
+            };
+        case 'runs-by-repo':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'run-counts',
+                    group: 'repo',
+                    rows: groupCount(runs, (run) => run.repo),
+                },
+            };
+        case 'runs-by-runner':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'run-counts',
+                    group: 'runner',
+                    rows: groupCount(runs, runnerKey),
+                },
+            };
+        case 'runs-by-model':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'run-counts',
+                    group: 'model',
+                    rows: groupCount(runs, (run) => modelKey(run, input.config)),
+                },
+            };
+        case 'runs-by-tier':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'run-counts',
+                    group: 'tier',
+                    rows: groupCount(runs, tierKey),
+                },
+            };
+        case 'tokens-over-time':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: { kind: 'tokens-over-time', rows: buckets.map(tokenCountsForBucket) },
+            };
+        case 'tokens-by-action':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'token-counts',
+                    group: 'action',
+                    rows: groupTokens(runs, (run) => run.action),
+                },
+            };
+        case 'tokens-by-runner':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'token-counts',
+                    group: 'runner',
+                    rows: groupTokens(runs, runnerKey),
+                },
+            };
+        case 'tokens-by-model':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'token-counts',
+                    group: 'model',
+                    rows: groupTokens(runs, (run) => modelKey(run, input.config)),
+                },
+            };
+        case 'duration-by-action':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'durations',
+                    group: 'action',
+                    rows: groupDurations(runs, (run) => run.action),
+                },
+            };
+        case 'duration-over-time':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'duration-over-time',
+                    rows: buckets.map((bucket) => {
+                        const values = runs
+                            .filter((run) => findBucket(run.startedAt, buckets)?.bucket === bucket.bucket)
+                            .map((run) => runDurationMs(run))
+                            .filter((duration) => duration !== undefined);
+                        return {
+                            bucket: bucket.bucket,
+                            label: bucket.label,
+                            count: values.length,
+                            totalMs: values.reduce((total, value) => total + value, 0),
+                            averageMs: average(values),
+                            medianMs: median(values) ?? 0,
+                        };
+                    }),
+                },
+            };
+        case 'work-items-over-time':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: {
+                    kind: 'work-items-over-time',
+                    rows: buckets.map((bucket) => ({
+                        bucket: bucket.bucket,
+                        label: bucket.label,
+                        completed: workItemDurations.filter((row) => findBucket(row.completedAt, buckets)?.bucket === bucket.bucket).length,
+                    })),
+                },
+            };
+        case 'work-item-durations':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: { kind: 'work-item-durations', rows: workItemDurations },
+            };
+        case 'runs-over-time':
+            return {
+                window,
+                metric,
+                generatedAt: input.now.toISOString(),
+                summary,
+                detail: { kind: 'runs-over-time', rows: buckets.map(runCountsForBucket) },
+            };
+    }
+}
 const secretKeyPattern = /token|secret|key|password/i;
 function redact(value, keyHint = '') {
     if (secretKeyPattern.test(keyHint) && typeof value === 'string') {

package/dist/src/adapters/http/ui-server.js CHANGED Viewed

@@ -5,7 +5,7 @@ import { configuredTicketSource } from '../../domain/sources.js';
 import { createEventEnvelope } from '../../lib/event-log.js';
 import { writeJsonFile } from '../../lib/json-file.js';
 import { indexHtml } from './ui-assets.js';
-import { buildBoard, buildConfigView, buildEventsFeed, buildHealth, buildItemDetail, buildItemTranscripts, buildRuns, buildStatus, buildWorkspaces, } from './ui-data.js';
+import { buildBoard, buildConfigView, buildEventsFeed, buildHealth, buildItemDetail, buildItemTranscripts, buildMetrics, buildRuns, buildStatus, buildWorkspaces, } from './ui-data.js';
 function sendJson(res, status, body) {
     const payload = JSON.stringify(body, null, 2);
     res.writeHead(status, {
@@ -218,6 +218,16 @@ async function handleRequest(req, res, options, now, projectionUpdater) {
         }));
         return;
     }
+    if (resource === 'metrics' && segments.length === 1) {
+        sendJson(res, 200, await buildMetrics({
+            stateStore,
+            config,
+            now: now(),
+            window: url.searchParams.get('window') ?? undefined,
+            metric: url.searchParams.get('metric') ?? undefined,
+        }));
+        return;
+    }
     if (resource === 'events' && segments.length === 1) {
         const limitParam = url.searchParams.get('limit');
         sendJson(res, 200, await buildEventsFeed({

package/dist/src/core/policy-engine.js CHANGED Viewed

@@ -5,6 +5,16 @@ function isAwaitingApproval(issue) {
     const context = issue.context;
     return context.lastRunSentinel === awaitingApprovalRunnerSentinel;
 }
+function belowFailureRetryLimit(issue, config) {
+    if (config === undefined) {
+        return true;
+    }
+    const context = issue.context;
+    const failureCount = typeof context.failureCount === 'number' && Number.isInteger(context.failureCount)
+        ? context.failureCount
+        : 0;
+    return failureCount < config.retry.maxFailureRetries;
+}
 // Commands are matched as a token at the start of a (trimmed) line, not as a
 // substring anywhere in the body — so "I have *not* /approved this yet" or a
 // quoted reply containing /approved does not approve the gate.
@@ -77,7 +87,7 @@ export function createPolicyEngine() {
                 requiredAssignees: config.sources.github.policy.requiredAssignees,
             });
         },
-        needsWakeAction(issue, workflow = builtInDefaultWorkflowDefinition) {
+        needsWakeAction(issue, workflow = builtInDefaultWorkflowDefinition, config) {
             const context = issue.context;
             const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
             const lastCompletedAction = typeof context.lastCompletedAction === 'string' ? context.lastCompletedAction : undefined;
@@ -101,7 +111,7 @@ export function createPolicyEngine() {
                 return false;
             }
             if (lastFailureClass === 'quota') {
-                return true;
+                return belowFailureRetryLimit(issue, config);
             }
             const workflowAction = chooseWorkflowAction(issue, workflow);
             return workflowAction !== null && lastCompletedAction !== workflowAction.action;
@@ -219,7 +229,7 @@ export function createPolicyEngine() {
             const nextAction = resolveCustomCommand(issue, config)?.action ??
                 this.chooseAction(issue, workflow) ??
                 this.chooseRetryActionAfterHumanReply(issue, workflow);
-            if (nextAction === null || !this.needsWakeAction(issue, workflow)) {
+            if (nextAction === null || !this.needsWakeAction(issue, workflow, config)) {
                 return null;
             }
             return { action: nextAction, workflow };

package/dist/src/core/projection-updater.js CHANGED Viewed

@@ -203,9 +203,18 @@ async function applyEvent(current, event, ctx, config) {
             config !== undefined &&
             isCustomCommandAction(payload.action, config);
         const shouldClearSession = isForwardProgression || isFailed;
+        const currentFailureCount = typeof current.context.failureCount === 'number' &&
+            Number.isInteger(current.context.failureCount)
+            ? current.context.failureCount
+            : 0;
         const nextContext = {
             ...current.context,
             lastFailureClass: payload.failureClass,
+            failureCount: payload.failureClass !== undefined
+                ? currentFailureCount + 1
+                : payload.sentinel === doneRunnerSentinel || payload.sentinel === 'AWAITING_APPROVAL'
+                    ? 0
+                    : currentFailureCount,
             ...(payload.handledCommentId === undefined
                 ? {}
                 : { lastHandledCommentId: payload.handledCommentId }),

package/dist/src/domain/schema.js CHANGED Viewed

@@ -457,6 +457,11 @@ const wakeConfigBaseSchema = z.object({
         retainAfterWorkspaceCleanup: z.boolean().default(false),
     })
         .default({ enabled: false, retainAfterWorkspaceCleanup: false }),
+    retry: z
+        .object({
+        maxFailureRetries: z.number().int().positive().default(5),
+    })
+        .default({ maxFailureRetries: 5 }),
     runners: z.record(z.string(), runnerEntrySchema).default({
         fake: { kind: 'fake', cli: 'Fake' },
         'claude-haiku': {
@@ -656,6 +661,7 @@ export const wakeInfraConfigSchema = wakeConfigBaseSchema.pick({
     dev: true,
     scheduler: true,
     transcripts: true,
+    retry: true,
     ui: true,
     sources: true,
     sinks: true,

package/dist/src/version.js CHANGED Viewed

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "g9570500";
+export const wakeVersion = "gff20ef3";

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {