@njeybe/nativ 2.2.0 → 2.3.1

package/dist/server/studio-ui/shell/model.js

@@ -0,0 +1,192 @@
+// Pure client model: joins plan, telemetry, runs and escalations into one object per refresh.
+export const modelScript = String.raw `  // ─── Studio client model: buildModel(api) is pure ──────────────────────────
+  var RUN_ACTIVE = { spawning_worktree: 1, running: 1, verifying: 1, merging: 1 };
+  function isRunActive(run) { return !!run && !!RUN_ACTIVE[run.status]; }
+
+  /** Text before the first colon, at most 46 characters. */
+  function shortName(name) {
+    var head = String(name || '').split(':')[0].replace(/^\s+|\s+$/g, '');
+    if (head.length <= 46) return head;
+    return head.slice(0, 44).replace(/[\s,&]+\S*$/, '') + '…';
+  }
+
+  function toTime(value) {
+    var t = value ? Date.parse(value) : NaN;
+    return isNaN(t) ? null : t;
+  }
+
+  function positive(n) { return typeof n === 'number' && isFinite(n) && n > 0 ? n : null; }
+
+  /** Last non-empty line of a log tail, without colour codes. */
+  function lastLine(text) {
+    var lines = String(text || '').replace(/\x1b\[[0-9;?]*[A-Za-z]/g, '').split(/\r?\n/);
+    for (var i = lines.length - 1; i >= 0; i--) {
+      var line = lines[i].replace(/^\s+|\s+$/g, '');
+      if (line) return line.length > 240 ? line.slice(0, 240) + '…' : line;
+    }
+    return null;
+  }
+
+  function attemptsOf(task, running) {
+    var cb = task.circuitBreaker || {};
+    var attempt = (cb.consecutiveFailures || 0) + (running ? 1 : 0);
+    if (!attempt && task.status === 'blocked') {
+      var m = /(\d+)\s+(?:fix\s+)?attempts?/i.exec(task.notes || '');
+      attempt = m ? Number(m[1]) : 0;
+    }
+    return attempt || null;
+  }
+
+  function buildTask(t, milestoneId, index) {
+    var b = index.breakdown[t.id] || null;
+    var run = index.run[t.id] || null;
+    var esc1 = index.escalation[t.id] || null;
+    var running = t.status === 'in_progress';
+    var startT = b ? toTime(b.startedAt) : null;
+    if (startT == null && run && isRunActive(run)) startT = toTime(run.startedAt);
+    var cost = b && b.actual ? positive(b.actual.costUsd) : null;
+    if (cost == null && b && b.estimated) cost = positive(b.estimated.costUsd);
+    return {
+      id: t.id,
+      title: t.title || t.id,
+      description: t.description || '',
+      status: t.status,
+      agent: t.assignedSubagent || null,
+      deps: t.dependencies || [],
+      files: t.targetFiles || [],
+      verify: t.verificationCommand || '',
+      milestoneId: milestoneId,
+      children: [],
+      waitingOn: [],
+      isAvailable: !!t.isAvailable,
+      reason: t.status === 'blocked' && t.notes ? String(t.notes).replace(/^\s+|\s+$/g, '') || null : null,
+      attempt: attemptsOf(t, running),
+      maxAttempts: (t.circuitBreaker && t.circuitBreaker.maxThreshold) || 3,
+      startT: startT,
+      endT: t.status === 'completed' && b ? toTime(b.completedAt) : null,
+      durationMs: b ? positive(b.durationMs) : null,
+      checkMs: b && b.verification ? positive(b.verification.durationMs) : null,
+      costUsd: cost,
+      run: run,
+      latestLog: lastLine(index.logTail[t.id]),
+      escalation: esc1,
+      hasProposal: !!(esc1 && esc1.proposedPatch)
+    };
+  }
+
+  function indexApi(api) {
+    var index = { breakdown: {}, run: {}, escalation: {}, logTail: api.logTail || {} };
+    ((api.telemetry && api.telemetry.taskBreakdowns) || []).forEach(function (b) {
+      if (b && b.taskId) index.breakdown[b.taskId] = b;
+    });
+    (api.runs || []).forEach(function (r) {
+      var have = r && index.run[r.taskId];
+      if (r && r.taskId && (!have || (isRunActive(r) && !isRunActive(have)))) index.run[r.taskId] = r;
+    });
+    (api.escalations || []).forEach(function (e) {
+      var pending = e && (!e.status || e.status === 'pending_review');
+      if (pending && e.taskId && !index.escalation[e.taskId]) index.escalation[e.taskId] = e;
+    });
+    return index;
+  }
+
+  function finishMilestone(m) {
+    m.total = m.tasks.length;
+    m.done = m.tasks.filter(function (t) { return t.status === 'completed'; }).length;
+    var ends = m.tasks.map(function (t) { return t.endT || 0; });
+    m.lastEndT = Math.max.apply(null, [0].concat(ends)) || null;
+    m.workMs = m.tasks.reduce(function (sum, t) { return sum + (t.durationMs || 0); }, 0);
+    var costs = m.tasks.filter(function (t) { return t.costUsd != null; });
+    m.costUsd = costs.length ? costs.reduce(function (sum, t) { return sum + t.costUsd; }, 0) : null;
+  }
+
+  function linkTasks(tasks, byId) {
+    tasks.forEach(function (t) {
+      t.deps.forEach(function (d) {
+        var parent = byId[d];
+        if (parent && parent.children.indexOf(t.id) === -1) parent.children.push(t.id);
+        if (!parent || parent.status !== 'completed') t.waitingOn.push(d);
+      });
+    });
+  }
+
+  function needsYouItems(tasks, byId, escalations) {
+    var seen = {}, items = [];
+    var add = function (t) {
+      seen[t.id] = true;
+      items.push({ taskId: t.id, task: t, escalation: t.escalation, hasProposal: t.hasProposal,
+        kind: t.status === 'blocked' ? 'stuck' : 'question' });
+    };
+    tasks.forEach(function (t) { if (t.status === 'blocked') add(t); });
+    (escalations || []).forEach(function (e) {
+      var pending = e && (!e.status || e.status === 'pending_review');
+      if (pending && byId[e.taskId] && !seen[e.taskId]) add(byId[e.taskId]);
+    });
+    return items;
+  }
+
+  function summaryOf(api, milestones, tasks) {
+    var act = api.telemetry && api.telemetry.summary && api.telemetry.summary.actual;
+    var st = api.status && api.status.telemetry;
+    var pick = function (a, b) { return a != null && isFinite(a) ? a : (b != null && isFinite(b) ? b : null); };
+    var contracts = api.status && api.status.contracts;
+    var done = tasks.filter(function (t) { return t.status === 'completed'; }).length;
+    return {
+      spendUsd: pick(act && act.spendUsd, st && st.actualSpendUsd),
+      cacheHitRate: pick(act && act.cacheHitRate, st && st.cacheHitRate),
+      cacheSavingsUsd: pick(act && act.cacheSavingsUsd, null),
+      contractsPresent: contracts ? Object.keys(contracts).filter(function (k) { return contracts[k]; }).length : null,
+      contractsTotal: 5,
+      milestonesTotal: milestones.length,
+      milestonesDone: milestones.filter(function (m) { return m.total > 0 && m.done === m.total; }).length,
+      tasksTotal: tasks.length,
+      tasksDone: done,
+      tasksLeft: tasks.length - done
+    };
+  }
+
+  /** api = { milestones, status, telemetry, runs, escalations, logTail }, the raw slices from the server. */
+  function buildModel(api) {
+    api = api || {};
+    var index = indexApi(api);
+    var tasks = [], byId = {};
+    var milestones = (api.milestones || []).map(function (m, i) {
+      var list = (m.tasks || []).map(function (t) {
+        var task = buildTask(t, m.id, index);
+        byId[task.id] = task;
+        tasks.push(task);
+        return task;
+      });
+      return { id: m.id, name: m.name || m.id, short: shortName(m.name || m.id), status: m.status, idx: i, tasks: list };
+    });
+    linkTasks(tasks, byId);
+    milestones.forEach(finishMilestone);
+    var active = null;
+    milestones.some(function (m) {
+      var open = m.tasks.some(function (t) { return t.status !== 'completed'; });
+      if (open) active = m.id;
+      return open;
+    });
+    if (!active && milestones.length) active = milestones[milestones.length - 1].id;
+    return {
+      milestones: milestones,
+      tasks: tasks,
+      byId: byId,
+      activeMilestoneId: active,
+      running: tasks.filter(function (t) { return t.status === 'in_progress'; }),
+      stuck: tasks.filter(function (t) { return t.status === 'blocked'; }),
+      needsYou: needsYouItems(tasks, byId, api.escalations),
+      summary: summaryOf(api, milestones, tasks)
+    };
+  }
+
+  /** Stores the model and keeps the shared milestone selection valid. */
+  Studio.setModel = function (model) {
+    Studio.model = model;
+    var S = Studio.state;
+    var known = model.milestones.some(function (m) { return m.id === S.milestoneId; });
+    if (!known) S.milestoneId = model.activeMilestoneId;
+  };
+  Studio.buildModel = buildModel;
+
+`;

package/dist/server/studio-ui/shell/paint.d.ts

@@ -0,0 +1 @@
+export declare const paintScript: string;

package/dist/server/studio-ui/shell/paint.js

@@ -0,0 +1,154 @@
+// Painting: pages, sidebar, banner, plus small fragments the kept pages still use.
+export const paintScript = String.raw `  // ─── Painting ──────────────────────────────────────────────────────────────
+  function cssEsc(v) { return window.CSS && CSS.escape ? CSS.escape(v) : String(v).replace(/["\\]/g, '\\$&'); }
+
+  function focusMemo(root) {
+    var el = document.activeElement;
+    if (!el || el === document.body || el === root || !root.contains(el)) return null;
+    var sel = null;
+    if (el.id) sel = '#' + cssEsc(el.id);
+    else if (el.getAttribute('data-act')) {
+      sel = '[data-act="' + cssEsc(el.getAttribute('data-act')) + '"]';
+      if (el.getAttribute('data-key')) sel += '[data-key="' + cssEsc(el.getAttribute('data-key')) + '"]';
+    } else if (el.hasAttribute('data-ms-select')) sel = '[data-ms-select]';
+    return sel ? { sel: sel, start: el.selectionStart, end: el.selectionEnd } : null;
+  }
+
+  function restoreFocus(root, memo) {
+    if (!memo) return;
+    var el = root.querySelector(memo.sel);
+    if (!el || el.disabled) return;
+    el.focus({ preventScroll: true });
+    if (memo.start != null && typeof el.setSelectionRange === 'function') {
+      try { el.setSelectionRange(memo.start, memo.end); } catch (e) { /* ignore */ }
+    }
+  }
+
+  /** A page is loading until every server slice it depends on has answered once. */
+  function isPageLoading(def) {
+    return (def.deps || []).some(function (d) { return PIPE_PATHS[d] && !pipe.loaded[d]; });
+  }
+
+  function pageCtx(panel) {
+    return { model: Studio.model, state: Studio.state, fmt: fmt, ui: ui, width: panel ? panel.clientWidth : 0 };
+  }
+
+  /** Renders one page into its panel; keeps focus and skips the write when nothing changed. */
+  function paintPage(id) {
+    var def = Studio.pages[id];
+    var panel = $('panel-' + id);
+    if (!def || !panel || !def.render) return;
+    var ctx = pageCtx(panel);
+    var html = isPageLoading(def) || !Studio.model ? (def.skeleton ? def.skeleton(ctx) : ui.skeleton()) : def.render(ctx);
+    panel.setAttribute('aria-busy', String(isPageLoading(def)));
+    if (panel.__html === html) return;
+    var memo = focusMemo(panel);
+    panel.innerHTML = html;
+    panel.__html = html;
+    restoreFocus(panel, memo);
+  }
+
+  /** Repaints a page (kept pages call this after their own state changes). */
+  function repaint(view) {
+    if (Studio.state.view !== view) return;
+    paintPage(view);
+    paintChrome();
+  }
+  Studio.repaint = function (id) { paintPage(id || Studio.state.view); };
+
+  function repaintFor(parts) {
+    var id = Studio.state.view;
+    var def = Studio.pages[id];
+    if (!def || !def.render) return;
+    if (!parts || (def.deps || []).some(function (d) { return parts.indexOf(d) !== -1; })) paintPage(id);
+  }
+
+  function paintChrome() {
+    var side = $('side-nav');
+    var main = mainWorktree();
+    var agents = pipe.worktrees.filter(function (w) { return w.isAgentWorktree; }).length;
+    var s = pipe.report && pipe.report.summary;
+    var navHtml = Studio.sidebarHtml({
+      model: Studio.model, view: Studio.state.view,
+      worktreeCount: pipe.loaded.worktrees && !pipe.errors.worktrees ? agents : null,
+      benchmarkText: s ? compactNum(Number(s.averageThroughputOpsPerSec) || 0) : ''
+    });
+    if (side.__html !== navHtml) { side.innerHTML = navHtml; side.__html = navHtml; }
+    var foot = $('side-foot');
+    var footHtml = Studio.sideFootHtml({ root: main ? String(main.path || '') : '', branch: main ? (main.branch || 'detached') : '' });
+    if (foot.__html !== footHtml) { foot.innerHTML = footHtml; foot.__html = footHtml; }
+    var lost = !!(pipe.errors.tasks || pipe.errors.status) || live.mode === 'offline';
+    $('banner').hidden = !lost;
+  }
+
+  /** One entry point after data or state changes: model, sidebar, current page, panel, palette. */
+  function refreshUi(parts) {
+    rebuildModel();
+    paintChrome();
+    repaintFor(parts);
+    refreshDetail();
+    refreshPalette();
+    backfillLogs();
+  }
+
+  var uiTimer = null, uiParts = {};
+  function queueUiRefresh(parts) {
+    parts.forEach(function (p) { uiParts[p] = true; });
+    if (uiTimer) return;
+    uiTimer = setTimeout(function () {
+      var list = Object.keys(uiParts);
+      uiParts = {};
+      uiTimer = null;
+      refreshUi(list);
+    }, 250);
+  }
+
+  /** Newest output line per task comes from the live stream and, once, from the log tail. */
+  function feedLogTail(entry) {
+    pipe.logTail[entry.taskId] = ((pipe.logTail[entry.taskId] || '') + (entry.chunk || '')).slice(-2000);
+    queueUiRefresh(['logs']);
+  }
+  var logAsked = {};
+  function backfillLogs() {
+    if (!Studio.model) return;
+    Studio.model.running.forEach(function (t) {
+      if (logAsked[t.id] || pipe.logTail[t.id] != null) return;
+      logAsked[t.id] = true;
+      api('/api/pipeline/tasks/logs?taskId=' + encodeURIComponent(t.id) + '&tailLines=20').then(function (body) {
+        pipe.logTail[t.id] = body.log || '';
+        queueUiRefresh(['logs']);
+      }, function () { /* no log yet */ });
+    });
+  }
+
+  // Fragments the kept pages (Worktrees, Benchmarks) still use.
+  function panelHead(title, lead, actions) {
+    return '<div class="panel-head"><div class="panel-title"><h1>' + title + '</h1>' + (lead ? '<p class="lead">' + lead + '</p>' : '') + '</div>' +
+      (actions ? '<div class="panel-actions">' + actions + '</div>' : '') + '</div>';
+  }
+
+  function progressBar(pct, key, label, tone) {
+    return '<div class="progress' + (tone ? ' ' + tone : '') + '" role="progressbar" aria-label="' + esc(label) + '" aria-valuemin="0" aria-valuemax="100" aria-valuenow="' + pct + '">' +
+      '<span style="width:' + pct + '%"></span></div>';
+  }
+
+  function errorCard(what, message, part) {
+    var missing = /No route for|NOT_FOUND|\(404\)/.test(message || '');
+    return '<div class="card state state-error" role="alert"><div class="state-icon">' + ICON.alert + '</div>' +
+      '<h2>Could not load ' + esc(what) + '</h2><p>' + esc(message) + '</p>' +
+      (missing ? '<p>This studio server does not expose the pipeline API yet. Restart it with a nativ build that includes the Mission Control endpoints.</p>' : '') +
+      '<button class="btn" type="button" data-act="retry" data-key="' + part + '">Retry</button></div>';
+  }
+
+  /** Data is still shown after a failed live refresh; say so instead of silently going stale. */
+  function staleNote(part) {
+    return pipe.errors[part] ? '<p class="notice" role="status">Showing the last synced data. Refresh failed: ' + esc(pipe.errors[part]) + '</p>' : '';
+  }
+
+  function skeletonCards(n, cls) {
+    var out = '';
+    for (var i = 0; i < n; i++) out += '<div class="card ' + (cls || 'kpi') + '"><div class="skeleton short"></div><div class="skeleton"></div><div class="skeleton"></div></div>';
+    return out;
+  }
+
+`;

package/dist/server/studio-ui/shell/palette-view.d.ts

@@ -0,0 +1 @@
+export declare const paletteViewScript: string;

package/dist/server/studio-ui/shell/palette-view.js

@@ -0,0 +1,60 @@
+// Pure command palette logic: what a query finds and how the list is drawn.
+export const paletteViewScript = String.raw `  // ─── Command palette (pure) ─────────────────────────────────────────────────
+  var PALETTE_MAX = 9;
+
+  function taskHaystack(t) {
+    var info = agentInfo(t.agent);
+    return [t.id, t.title, t.agent || '', info.label].concat(t.files).join(' ').toLowerCase();
+  }
+
+  function emptyQueryTasks(model) {
+    var done = model.tasks.filter(function (t) { return t.status === 'completed'; });
+    var timed = done.filter(function (t) { return t.endT; }).sort(function (a, b) { return b.endT - a.endT; });
+    var rest = done.filter(function (t) { return !t.endT; }).reverse();
+    return model.running.concat(model.stuck, timed, rest);
+  }
+
+  function matchRank(t, q) {
+    var id = t.id.toLowerCase();
+    return id === q ? 0 : id.indexOf(q) === 0 ? 1 : 2;
+  }
+
+  /** Pages first ("Go to Flow"), then tasks matching id, title, agent id, agent label or any file. */
+  Studio.paletteItems = function (query) {
+    var model = Studio.model;
+    var q = String(query || '').replace(/^\s+|\s+$/g, '').toLowerCase();
+    var pages = q ? Studio.order.filter(function (p) { return p.label.toLowerCase().indexOf(q) !== -1; })
+      .map(function (p) { return { page: p }; }) : [];
+    var tasks = [];
+    if (model) {
+      tasks = q ? model.tasks.filter(function (t) { return taskHaystack(t).indexOf(q) !== -1; })
+        .sort(function (a, b) { return matchRank(a, q) - matchRank(b, q); }) : emptyQueryTasks(model);
+    }
+    return pages.concat(tasks.map(function (t) { return { task: t }; })).slice(0, PALETTE_MAX);
+  };
+
+  Studio.paletteFrame = function () {
+    return '<div class="pal" role="dialog" aria-label="Find a task" aria-modal="true">' +
+      '<input id="pal-q" type="text" placeholder="Search by task id, title, agent or file" autocomplete="off" ' +
+      'role="combobox" aria-expanded="true" aria-controls="pal-list" aria-label="Find a task">' +
+      '<ul id="pal-list" role="listbox"></ul>' +
+      '<div class="hint"><span>Up and down to move</span><span>Enter to open</span><span>Esc to close</span></div></div>';
+  };
+
+  /** Rows for the listbox; sel is the highlighted index. */
+  Studio.paletteListHtml = function (items, sel, query) {
+    if (!items.length) {
+      return '<li class="faint pal-none">No task matches. Try an id like task-31 or a file name.</li>';
+    }
+    return items.map(function (it, i) {
+      var on = ' role="option" id="pal-opt-' + i + '" data-i="' + i + '" aria-selected="' + (i === sel) + '">';
+      if (it.page) {
+        return '<li' + on + '<span class="pal-ico">' + ui.svg(it.page.icon) + '</span><span class="t">Go to ' + esc(it.page.label) + '</span></li>';
+      }
+      var t = it.task;
+      return '<li' + on + ui.statusIcon(t.status) + '<span class="mono faint hide-sm">' + esc(t.id) + '</span>' +
+        '<span class="t">' + esc(t.title) + '</span><span class="hide-sm">' + ui.agentChip(t.agent) + '</span></li>';
+    }).join('');
+  };
+
+`;

package/dist/server/studio-ui/shell/palette.d.ts

@@ -0,0 +1 @@
+export declare const paletteScript: string;

package/dist/server/studio-ui/shell/palette.js

@@ -0,0 +1,80 @@
+// Command palette: Ctrl+K / Cmd+K / "/" to open, arrows and Enter to pick, Esc to close.
+export const paletteScript = String.raw `  // ─── Command palette ───────────────────────────────────────────────────────
+  var pal = { open: false, sel: 0, items: [], opener: null };
+
+  function drawPalette() {
+    var q = $('pal-q');
+    pal.items = Studio.paletteItems(q ? q.value : '');
+    if (pal.sel >= pal.items.length) pal.sel = 0;
+    $('pal-list').innerHTML = Studio.paletteListHtml(pal.items, pal.sel);
+    if (q) q.setAttribute('aria-activedescendant', pal.items.length ? 'pal-opt-' + pal.sel : '');
+    var cur = $('pal-opt-' + pal.sel);
+    if (cur && cur.scrollIntoView) cur.scrollIntoView({ block: 'nearest' });
+  }
+
+  function openPalette() {
+    if (pal.open) return;
+    pal.open = true;
+    pal.sel = 0;
+    pal.opener = document.activeElement;
+    $('pal').innerHTML = Studio.paletteFrame();
+    $('pal').hidden = false;
+    drawPalette();
+    $('pal-q').focus();
+  }
+
+  function closePalette() {
+    if (!pal.open) return;
+    pal.open = false;
+    $('pal').hidden = true;
+    $('pal').innerHTML = '';
+    if (pal.opener && document.body.contains(pal.opener) && pal.opener.focus) pal.opener.focus();
+  }
+
+  function refreshPalette() { if (pal.open) drawPalette(); }
+
+  function pickPalette(i) {
+    var it = pal.items[i];
+    if (!it) return;
+    pal.opener = null;
+    closePalette();
+    if (it.page) { Studio.go(it.page.id); return; }
+    Studio.state.milestoneId = it.task.milestoneId;
+    openDetail(it.task.id);
+    repaintFor(null);
+  }
+
+  $('btn-find').addEventListener('click', openPalette);
+  $('pal').addEventListener('click', function (e) {
+    var li = e.target.closest('li[data-i]');
+    if (li) { pickPalette(Number(li.getAttribute('data-i'))); return; }
+    if (e.target.id === 'pal') closePalette();
+  });
+  $('pal').addEventListener('input', function () { pal.sel = 0; drawPalette(); });
+
+  function typingInField() {
+    var a = document.activeElement;
+    return !!a && /^(input|select|textarea)$/i.test(a.tagName);
+  }
+
+  document.addEventListener('keydown', function (e) {
+    if ((e.ctrlKey || e.metaKey) && String(e.key).toLowerCase() === 'k') {
+      e.preventDefault();
+      if (pal.open) closePalette(); else openPalette();
+      return;
+    }
+    if (e.key === '/' && !pal.open && !typingInField() && !e.ctrlKey && !e.metaKey) { e.preventDefault(); openPalette(); return; }
+    if (pal.open) {
+      var n = Math.max(1, pal.items.length);
+      if (e.key === 'Escape') { e.preventDefault(); closePalette(); }
+      else if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+        e.preventDefault();
+        pal.sel = (pal.sel + (e.key === 'ArrowDown' ? 1 : -1) + n) % n;
+        drawPalette();
+      } else if (e.key === 'Enter') { e.preventDefault(); pickPalette(pal.sel); }
+      return;
+    }
+    if (e.key === 'Escape' && Studio.state.detailTaskId && !document.querySelector('dialog[open]')) closeDetail(false);
+  });
+
+`;

package/dist/server/studio-ui/shell/pipeline-state.d.ts

@@ -0,0 +1 @@
+export declare const pipelineStateScript: string;

package/dist/server/studio-ui/shell/pipeline-state.js

@@ -0,0 +1,152 @@
+// Pipeline data store, fetching, and the model rebuild that follows every change.
+export const pipelineStateScript = String.raw `  // ─── Pipeline state ────────────────────────────────────────────────────────
+  var PIPE_PATHS = {
+    status: '/api/pipeline/status',
+    tasks: '/api/pipeline/tasks',
+    worktrees: '/api/pipeline/worktrees',
+    benchmarks: '/api/pipeline/benchmarks',
+    runs: '/api/pipeline/tasks/runs',
+    telemetry: '/api/pipeline/telemetry/detailed',
+    escalations: '/api/pipeline/escalations?status=pending_review',
+    triage: '/api/pipeline/triage/status'
+  };
+  var ALL_PARTS = ['status', 'tasks', 'worktrees', 'benchmarks', 'runs', 'telemetry', 'escalations', 'triage'];
+  var REDUCED_MOTION = window.matchMedia ? window.matchMedia('(prefers-reduced-motion: reduce)') : { matches: false };
+
+  var pipe = {
+    status: null,
+    milestones: [],
+    worktrees: [],
+    runs: [],
+    report: null,
+    telemetry: null,
+    escalations: [],
+    triage: null,
+    triageRunning: {},
+    triageRecent: {},
+    triageLast: null,
+    logTail: {},
+    loaded: {},
+    errors: {},
+    busy: {},
+    syncedAt: null
+  };
+
+  function allTasks() {
+    var out = [];
+    (pipe.milestones || []).forEach(function (m) { (m.tasks || []).forEach(function (t) { out.push(t); }); });
+    return out;
+  }
+  function taskById(id) {
+    var found = null;
+    allTasks().some(function (t) { if (t.id === id) { found = t; return true; } return false; });
+    return found;
+  }
+
+  function setProjectName(name) {
+    if (!name) return;
+    var el = $('project-name');
+    if (el) { el.textContent = name; el.hidden = false; }
+    document.title = 'Nativ Studio · ' + name;
+  }
+
+  function fetchPipeline(parts) {
+    return Promise.all(parts.map(function (part) {
+      return api(PIPE_PATHS[part]).then(function (body) {
+        applyPipeline(part, body);
+        pipe.errors[part] = null;
+      }, function (e) {
+        pipe.errors[part] = e.message;
+      }).then(function () { pipe.loaded[part] = true; });
+    })).then(function () {
+      pipe.syncedAt = new Date();
+      refreshUi(parts);
+    });
+  }
+
+  function applyPipeline(part, body) {
+    if (part === 'status') {
+      pipe.status = body.pipeline || null;
+      if (pipe.status) setProjectName(pipe.status.projectName);
+    } else if (part === 'tasks') {
+      pipe.milestones = Array.isArray(body.milestones) ? body.milestones : [];
+      setProjectName(body.projectName);
+    } else if (part === 'worktrees') {
+      pipe.worktrees = Array.isArray(body.worktrees) ? body.worktrees : [];
+    } else if (part === 'runs') {
+      pipe.runs = Array.isArray(body.runs) ? body.runs : [];
+    } else if (part === 'benchmarks') {
+      pipe.report = body.report || null;
+    } else if (part === 'telemetry') {
+      pipe.telemetry = { summary: body.summary || {}, taskBreakdowns: Array.isArray(body.taskBreakdowns) ? body.taskBreakdowns : [] };
+    } else if (part === 'escalations') {
+      pipe.escalations = Array.isArray(body.escalations) ? body.escalations : [];
+      syncHealTab();
+      renderTriageChip();
+    } else if (part === 'triage') {
+      pipe.triage = body;
+      renderTriageChip();
+    }
+  }
+
+  /** Rebuilds the client model from the raw slices. */
+  function rebuildModel() {
+    Studio.setModel(buildModel({
+      milestones: pipe.milestones,
+      status: pipe.status,
+      telemetry: pipe.telemetry,
+      runs: pipe.runs,
+      escalations: pipe.escalations,
+      logTail: pipe.logTail
+    }));
+  }
+
+  /** Newest pending escalation for a task (the list arrives newest first). */
+  function escalationFor(taskId) {
+    var found = null;
+    (pipe.escalations || []).some(function (e) { if (e.taskId === taskId && e.status === 'pending_review') { found = e; return true; } return false; });
+    return found;
+  }
+
+  /** The main (non-agent) worktree is the workspace root and carries the active branch. */
+  function mainWorktree() {
+    var main = null;
+    pipe.worktrees.some(function (w) { if (!w.isAgentWorktree) { main = w; return true; } return false; });
+    return main;
+  }
+
+  /** 1234 becomes "1.2k" so the sidebar badge stays small. */
+  function compactNum(n) {
+    if (!isFinite(n)) return '–';
+    if (n >= 1e6) return (n / 1e6).toFixed(1).replace(/\.0$/, '') + 'M';
+    if (n >= 1e3) return (n / 1e3).toFixed(1).replace(/\.0$/, '') + 'k';
+    return String(Math.round(n));
+  }
+
+  /** Newest Just-finished style helpers live in pages; here only what the runner tools need. */
+  var RUN_LABEL = {
+    spawning_worktree: 'Worktree', running: 'Claude Running', verifying: 'Verifying', merging: 'Merging',
+    completed: 'Run completed', failed: 'Run failed', aborted: 'Run aborted'
+  };
+  function runFor(taskId) {
+    var found = null;
+    (pipe.runs || []).some(function (r) { if (r.taskId === taskId) { found = r; return true; } return false; });
+    return found;
+  }
+  function upsertRun(run) {
+    if (!run || !run.taskId) return;
+    pipe.runs = [run].concat((pipe.runs || []).filter(function (r) { return r.taskId !== run.taskId; }));
+  }
+  function elapsedOf(run) {
+    if (!run || !run.startedAt) return null;
+    var ms = isRunActive(run) ? Date.now() - Date.parse(run.startedAt) : run.durationMs;
+    return typeof ms === 'number' && isFinite(ms) && ms >= 0 ? ms : null;
+  }
+  /** mm:ss elapsed time shown in the console drawer. */
+  function mmss(ms) {
+    var total = Math.floor((ms || 0) / 1000);
+    var mm = Math.floor(total / 60), ss = total % 60;
+    return (mm < 10 ? '0' : '') + mm + ':' + (ss < 10 ? '0' : '') + ss;
+  }
+
+`;

package/dist/server/studio-ui/shell/proposals.d.ts

@@ -0,0 +1 @@
+export declare const proposalsScript: string;