toolroll 0.5.0

package/dist/workspace-motion.js

@@ -0,0 +1,133 @@
+/** Motion adapts presentation only. Native navigation, forms and tab state
+ * remain owned by their existing handlers. No network or credential access. */
+export const WORKSPACE_MOTION_CSS = String.raw `
+:root {
+  --panel-open-dur: 250ms;
+  --panel-close-dur: 150ms;
+  --panel-translate-y: 8px;
+  --panel-blur: 0px;
+  --tabs-text-muted: var(--muted-foreground);
+  --tabs-text-active: var(--foreground);
+  --tabs-bar-bg: transparent;
+  --tabs-pill-bg: var(--foreground);
+}
+/* Keep the existing underline tabs and 44px controls, not the demo's pill. */
+.result-tabs.t-tabs { display: flex; padding: 0; border-radius: 0; background: transparent; }
+.result-tabs .t-tab { height: auto; min-height: 44px; border-radius: 0; }
+.result-tabs.t-tabs a[aria-selected="true"] { border-bottom-color: transparent; }
+.result-tabs .t-tabs-pill { top: auto; bottom: 0; height: 2px; border-radius: 0; }
+.t-acc-panel-inner { min-height: 0; }
+.t-acc .t-acc-panel-inner { filter: none; }
+.t-acc[data-open="false"] > .t-acc-panel { grid-template-rows: 0fr; }
+.t-acc[data-open="false"] > .t-acc-panel > .t-acc-panel-inner { opacity: 0; }
+.t-acc > summary { cursor: pointer; }
+.t-acc > summary .t-acc-chevron { width: 14px; height: 14px; margin-left: .4rem; }
+.t-acc > summary .t-acc-chevron svg { width: 100%; height: 100%; }
+.t-acc > summary::before, .t-acc > summary::after { content: none !important; }
+.t-acc > summary::-webkit-details-marker { display: none; }
+.t-acc > summary { list-style: none; }
+.switcher[open] .switcher-menu.t-dropdown { animation: none; }
+/* Cross-document entry/exit: links and POSTs are never held for motion.
+ * Unsupported browsers keep normal, immediate navigation. */
+.chat-result { view-transition-name: so-result; }
+::view-transition-old(so-result) { animation: result-leave var(--panel-close-dur) var(--panel-ease) both; }
+::view-transition-new(so-result) { animation: result-enter var(--panel-open-dur) var(--panel-ease) both; }
+@keyframes result-enter { from { opacity: 0; transform: translateY(var(--panel-translate-y)); } }
+@keyframes result-leave { to { opacity: 0; transform: translateY(var(--panel-translate-y)); } }
+@media (prefers-reduced-motion: reduce) {
+  ::view-transition-old(so-result), ::view-transition-new(so-result) { animation: none !important; }
+}
+`;
+export const WORKSPACE_MOTION_SCRIPT = String.raw `
+(function(){
+  var reduced=window.matchMedia('(prefers-reduced-motion: reduce)');
+  var closers=new WeakMap();
+  function duration(name,fallback){
+    if(reduced.matches)return 0;
+    var raw=getComputedStyle(document.documentElement).getPropertyValue(name).trim();
+    var n=parseFloat(raw);return Number.isFinite(n)?n*(raw.endsWith('ms')?1:1000):fallback;
+  }
+  function enhanceDetails(details,menu){
+    if(details.dataset.motionReady)return;
+    var head=details.querySelector(':scope > summary');if(!head)return;
+    var panel,inner;
+    if(menu){
+      panel=details.querySelector(':scope > .switcher-menu, :scope > .work-tools-menu');if(!panel)return;
+      inner=panel;panel.classList.add('t-dropdown');panel.dataset.origin='top-left';
+    }else{
+      panel=document.createElement('div');panel.className='t-acc-panel';
+      inner=document.createElement('div');inner.className='t-acc-panel-inner';
+      Array.from(details.childNodes).forEach(function(node){if(node!==head)inner.appendChild(node);});
+      panel.appendChild(inner);details.appendChild(panel);details.classList.add('t-acc');
+      var chevron=document.createElement('span');chevron.className='t-acc-chevron';chevron.setAttribute('aria-hidden','true');
+      chevron.innerHTML='<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5"><path d="M4 6.5L8 10.5L12 6.5"/></svg>';
+      // Use the existing icon when present, rather than rendering two.
+      var old=head.querySelector(':scope > svg');if(old)old.remove();head.appendChild(chevron);
+    }
+    details.dataset.motionReady='true';
+    var timer=null,closing=false;
+    function paint(open){
+      details.dataset.open=String(open);head.setAttribute('aria-expanded',String(open));inner.inert=!open;
+      if(menu){panel.classList.toggle('is-open',open);if(open)panel.classList.remove('is-closing');}
+    }
+    function cancel(){if(timer!==null)clearTimeout(timer);timer=null;}
+    function finish(){closing=false;details.open=false;panel.classList.remove('is-closing');timer=null;paint(false);}
+    function open(){
+      cancel();closing=false;details.open=true;paint(false);panel.classList.remove('is-closing');
+      void panel.offsetHeight;paint(true);
+    }
+    function close(){
+      cancel();closing=true;
+      if(inner.contains(document.activeElement))head.focus();
+      paint(false);if(menu)panel.classList.add('is-closing');
+      var ms=duration(menu?'--dropdown-close-dur':'--acc-collapse',menu?150:250);
+      if(ms===0)finish();else timer=setTimeout(finish,ms);
+    }
+    paint(details.open);
+    head.addEventListener('click',function(ev){
+      if(ev.defaultPrevented||ev.ctrlKey||ev.metaKey||ev.altKey||ev.shiftKey||ev.button!==0)return;
+      if(ev.target.closest('a,button,input,select,textarea'))return;
+      ev.preventDefault();if(details.open&&!closing)close();else open();
+    });
+    // External close (Escape/outside click/group exclusivity) stays immediate.
+    details.addEventListener('toggle',function(){
+      if(!details.open){cancel();closing=false;panel.classList.remove('is-closing');paint(false);}
+      else if(!closing)paint(true);
+    });
+    closers.set(details,function(){if(closing){cancel();finish();}});
+  }
+  function enhanceTabs(bar){
+    if(bar.dataset.motionReady)return;
+    var tabs=Array.from(bar.querySelectorAll('[data-result-tab]'));if(!tabs.length)return;
+    bar.dataset.motionReady='true';bar.classList.add('t-tabs');
+    var pill=document.createElement('span');pill.className='t-tabs-pill';pill.setAttribute('aria-hidden','true');bar.prepend(pill);
+    tabs.forEach(function(tab){tab.classList.add('t-tab');});
+    function move(animate){
+      var tab=tabs.find(function(t){return t.getAttribute('aria-selected')==='true';})||tabs[0];
+      var prev=pill.style.transition;
+      if(!animate)pill.style.transition='none';
+      pill.style.transform='translateX('+tab.offsetLeft+'px)';pill.style.width=tab.offsetWidth+'px';
+      if(!animate){void pill.offsetWidth;pill.style.transition=prev;}
+    }
+    // Selection and keyboard behavior remain in RESULT_REVIEW_SCRIPT.
+    new MutationObserver(function(){move(!reduced.matches);}).observe(bar,{subtree:true,attributes:true,attributeFilter:['aria-selected']});
+    move(false);
+    if(typeof ResizeObserver!=='undefined')new ResizeObserver(function(){move(false);}).observe(bar);
+    else window.addEventListener('resize',function(){move(false);});
+  }
+  function scan(){
+    document.querySelectorAll('details.switcher,details.work-tools').forEach(function(d){enhanceDetails(d,true);});
+    document.querySelectorAll('details.nav-group,details.task-history,details.decision-context,details.result-knowledge,details.chat-activity-details,details.result-pin,details.result-notes,details.result-details').forEach(function(d){enhanceDetails(d,false);});
+    document.querySelectorAll('.result-tabs').forEach(enhanceTabs);
+  }
+  scan();
+  reduced.addEventListener('change',function(){if(reduced.matches)document.querySelectorAll('details[data-motion-ready]').forEach(function(d){var finish=closers.get(d);if(finish)finish();});});
+  // Live chat can insert new disclosures. Only enhance fresh nodes; never
+  // replace content or read field values, and never restart existing motion.
+  var queued=false;
+  new MutationObserver(function(records){
+    if(queued||!records.some(function(r){return r.addedNodes.length>0;}))return;
+    queued=true;queueMicrotask(function(){queued=false;scan();});
+  }).observe(document.body,{childList:true,subtree:true});
+})();
+`;

package/dist/workspace-revision.d.ts

@@ -0,0 +1,19 @@
+import type { Store } from './store.js';
+export type WorkspaceRevision = {
+    current(): string;
+    expiresAt(now: Date): number;
+};
+type WorkspaceValidator = {
+    etag: string;
+    revision: string;
+    expiresAt: number;
+};
+/** Per-server response metadata. Reads preserve insertion order; writes at
+ * capacity discard the oldest key before storing the supplied validator. */
+export declare class WorkspaceValidatorCache {
+    private readonly entries;
+    get(key: string): WorkspaceValidator | undefined;
+    set(key: string, validator: WorkspaceValidator): void;
+}
+export declare function prepareWorkspaceRevision(store: Store): WorkspaceRevision;
+export {};

package/dist/workspace-revision.js

@@ -0,0 +1,92 @@
+/** Durable invalidation for authenticated workspace reads. This is cache
+ * metadata only: it never grants access or certifies task/process state. */
+import { createHash } from 'node:crypto';
+import { DEFAULT_LIVENESS_MS } from './runner.js';
+const KEY = 'workspace-content:v1';
+const PREFIX = 'workspace_revision_v1_';
+const MAX_AGE_MS = 60_000;
+const OMIT = new Set(['schema_version', 'service_cursor', 'wake', 'notification_delivery',
+    'team_read', 'team_request', 'push_delivery', 'telegram_update', 'telegram_outbound_message', 'telegram_retry', 'bridge_lease']);
+const QUIET = {
+    runner: ['heartbeat_at'], claim: ['heartbeat_at', 'expires_at'], watch_lease: ['heartbeat_at', 'expires_at'],
+    watch_episode: ['ticks'], provider_readiness: ['observed_at'],
+};
+const identifier = (name) => `"${name.replaceAll('"', '""')}"`;
+/** Per-server response metadata. Reads preserve insertion order; writes at
+ * capacity discard the oldest key before storing the supplied validator. */
+export class WorkspaceValidatorCache {
+    entries = new Map();
+    get(key) { return this.entries.get(key); }
+    set(key, validator) {
+        if (this.entries.size >= 256)
+            this.entries.delete(this.entries.keys().next().value);
+        this.entries.set(key, validator);
+    }
+}
+export function prepareWorkspaceRevision(store) {
+    const db = store.raw();
+    const bump = `INSERT INTO service_cursor(key,value,updated_at) VALUES ('${KEY}',1,strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    ON CONFLICT(key) DO UPDATE SET value=service_cursor.value+1,updated_at=excluded.updated_at;`;
+    const wanted = new Map();
+    // Virtual tables (the FTS5 memory index) cannot carry triggers, and their
+    // shadow tables are derived views rebuilt from the stores of record.
+    const tables = db.prepare("SELECT name FROM sqlite_schema WHERE type='table' AND name NOT LIKE 'sqlite_%' AND sql NOT LIKE 'CREATE VIRTUAL%' AND name NOT LIKE 'memory_search%'").all();
+    for (const row of tables) {
+        const table = String(row['name']);
+        if (OMIT.has(table))
+            continue;
+        const columns = db.prepare(`PRAGMA table_info(${identifier(table)})`).all().map(column => String(column['name']));
+        const meaningful = columns.filter(column => !QUIET[table]?.includes(column));
+        const changes = meaningful.map(column => `OLD.${identifier(column)} IS NOT NEW.${identifier(column)}`);
+        // A routine beat is quiet, but a revival after a liveness/lease gap must
+        // invalidate an already-rendered "offline" view immediately.
+        if (table === 'runner')
+            changes.push(`NEW.heartbeat_at < OLD.heartbeat_at OR NEW.heartbeat_at >= strftime('%Y-%m-%dT%H:%M:%fZ',OLD.heartbeat_at,'+${DEFAULT_LIVENESS_MS / 1000} seconds')`);
+        if (table === 'claim' || table === 'watch_lease')
+            changes.push('NEW.heartbeat_at >= OLD.expires_at');
+        for (const event of ['INSERT', 'UPDATE', 'DELETE']) {
+            const guard = event === 'UPDATE' ? ` WHEN ${changes.join(' OR ')}` : '';
+            const body = `AFTER ${event} ON ${identifier(table)}${guard} BEGIN ${bump} END`;
+            const digest = createHash('sha256').update(body).digest('hex').slice(0, 16);
+            wanted.set(`${PREFIX}${table}_${event.toLowerCase()}_${digest}`, body);
+        }
+    }
+    // Only DDL and one metadata row are written here; no task/history scan or
+    // backfill holds the writer. Existing installations perform no DDL writes.
+    store.transact(() => {
+        const existing = db.prepare("SELECT name FROM sqlite_schema WHERE type='trigger' AND name LIKE ?").all(`${PREFIX}%`);
+        const installed = new Set(existing.map(row => String(row['name'])).filter(name => name.startsWith(PREFIX)));
+        for (const name of installed)
+            if (!wanted.has(name))
+                db.exec(`DROP TRIGGER ${identifier(name)}`);
+        for (const [name, body] of wanted)
+            if (!installed.has(name))
+                db.exec(`CREATE TRIGGER ${identifier(name)} ${body}`);
+        db.prepare('INSERT OR IGNORE INTO service_cursor(key,value,updated_at) VALUES (?,0,?)').run(KEY, new Date().toISOString());
+    });
+    const current = db.prepare('SELECT CAST(value AS TEXT) AS value FROM service_cursor WHERE key = ?');
+    const boundary = db.prepare(`SELECT MIN(at) AS at FROM (
+    SELECT MIN(expires_at) AS at FROM claim WHERE released_at IS NULL AND expires_at > ?
+    UNION ALL SELECT MIN(until) FROM hold WHERE until > ?
+    UNION ALL SELECT MIN(absolute_expiry) FROM operating_mode WHERE revoked_at IS NULL AND absolute_expiry > ?
+    UNION ALL SELECT MIN(strftime('%Y-%m-%dT%H:%M:%fZ',heartbeat_at,'+${DEFAULT_LIVENESS_MS / 1000} seconds')) FROM runner
+      WHERE retired_at IS NULL AND strftime('%Y-%m-%dT%H:%M:%fZ',heartbeat_at,'+${DEFAULT_LIVENESS_MS / 1000} seconds') >= ?
+    UNION ALL SELECT MIN(expires_at) FROM watch_lease WHERE expires_at > ?
+    UNION ALL SELECT MIN(expires_at) FROM capability WHERE expires_at > ?
+    UNION ALL SELECT MIN(reset_at) FROM quota WHERE reset_at > ?
+  )`);
+    return {
+        current() {
+            const value = current.get(KEY)?.['value'];
+            if (typeof value !== 'string' || !/^\d+$/.test(value))
+                throw new Error('Workspace revision is unavailable');
+            return `v1:${value}`;
+        },
+        expiresAt(now) {
+            const iso = now.toISOString();
+            const value = boundary.get(iso, iso, iso, iso, iso, iso, iso)?.['at'];
+            const at = typeof value === 'string' ? Date.parse(value) : NaN;
+            return Math.min(now.getTime() + MAX_AGE_MS, Number.isFinite(at) ? at : Infinity);
+        },
+    };
+}

package/dist/workspace-ui.d.ts

@@ -0,0 +1,204 @@
+/**
+ * The workspace's ONE display projection (package 1, 2026-09-13): the
+ * words, tone, and next action a task or result wears on every surface —
+ * Work rows, the task page's status box, the focused chat's journey card,
+ * the review cockpit's chip, and the completion receipt's heading. Pure
+ * functions over facts the store already records (task state, the dispatch
+ * diagnosis, the machine's proof verdict and its reasons, an operator's
+ * acceptance, the publication row); nothing here is a second lifecycle,
+ * and nothing here reads the agent's narrative as evidence of success.
+ *
+ * The vocabulary is the truthful-status contract from the workspace plan:
+ * a saved result with a failed check says "Changes saved, but checks
+ * failed"; a missing proof says "verification needed"; agent-reported
+ * checks say so; an accepted exception stays an exception; and nothing
+ * local is ever called shipped or deployed — "PR opened" and "Merge
+ * observed" name observed publication records, and deployment is never
+ * claimed without one.
+ */
+import type { DispatchDiagnosis } from "./dispatch.js";
+import { type ProofVerdict } from "./proof.js";
+import type { ReviewRetryState, TaskState } from "./store.js";
+import type { TaskControlView } from "./task-control.js";
+/** The Work destination's views — shortcuts over the same rows, never a
+ * persisted state. All is the default. */
+export type WorkView = "all" | "needs-you" | "running" | "completed";
+export declare const WORK_VIEWS: readonly {
+    key: WorkView;
+    label: string;
+    hint: string;
+    empty: string;
+}[];
+export declare function parseWorkView(raw: string | null): WorkView;
+/** The finished result's recorded facts, as `taskViewData`, dispatch, and
+ * the completed-work query already read them. */
+export type ResultFacts = {
+    runId: number | null;
+    /** The result run's role — a scout delivers a report, not a diff. */
+    role: string | null;
+    outcome: string | null;
+    verdict: ProofVerdict | null;
+    reasons: readonly string[];
+    accepted: boolean;
+    /** A no-change conclusion's two presence facts (handoff + sealed diff);
+     * undefined when the caller did not read them. */
+    recordComplete?: boolean;
+    /** This exact run's independent review (v50 retry projection), read
+     * per run so an older selected result keeps its own words; undefined
+     * when the caller did not read it, null when never requested. */
+    review?: ReviewFacts | null;
+};
+/** The result's review facts as `reviewRetryStateOf` records them, plus
+ * the one liveness fact the words depend on. */
+export type ReviewFacts = {
+    state: ReviewRetryState["state"];
+    /** The attempt in play: the next ordinal while queued, else the live or
+     * latest attempt's. */
+    attempt: number | null;
+    cap: number;
+    attempts: number;
+    retriesRemaining: number;
+    latestReason: string | null;
+    interrupted: boolean;
+    /** Who asked for the open (queued) request, when one is open. */
+    queuedBy: string | null;
+    queuedOrigin?: "operator" | "automatic" | null;
+    /** Whether the live attempt's reviewer worker is answering. */
+    reviewerAlive: boolean;
+};
+/** The review facts from the store's bounded retry projection — the same
+ * reading `diagnoseTaskDispatch` makes, so every surface starts from one
+ * record. `reviewerAlive` answers for the live attempt's runner. */
+export declare function reviewFactsOf(retry: ReviewRetryState | null, reviewerAlive: (runner: string) => boolean): ReviewFacts | null;
+/** The tokens a review in flight wears — the dispatch codes, unchanged. */
+export declare const REVIEW_TOKENS: ReadonlySet<string>;
+/**
+ * A review that is queued, running, failed with a retry left, or
+ * exhausted is the result's PRIMARY status — the machine is still
+ * deciding, and every surface must say so with the same words. A review
+ * never requested, or one that succeeded, adds nothing: the stored verdict
+ * (folded by the review where one landed) speaks. Words and tokens are
+ * the v50 dispatch contract; nothing here changes the lifecycle.
+ */
+export declare function reviewStatusOf(review: ReviewFacts | null): DisplayStatus | null;
+export type PublicationFacts = {
+    state: string;
+    prNumber: number | null;
+    prUrl: string | null;
+    remoteState: string | null;
+    lastCheckState: string | null;
+} | null;
+export type StatusTone = "attention" | "problem" | "live" | "ready" | "done" | "muted" | "neutral";
+export type NextAction = {
+    label: string;
+    /** Where the act lives — the page, not a URL, so every surface can
+     * build its own link (a task page anchors, a row links out). */
+    kind: "open-result" | "open-review" | "open-task" | "open-run" | "open-pr";
+};
+export type DisplayStatus = {
+    /** The stable `data-work-status` token pages and tests key off. */
+    token: string;
+    /** The main wording — the same words on every surface. */
+    label: string;
+    /** One plain sentence: the real reason when one is recorded, never an
+     * invented cause, repair, retry time, or percentage. */
+    detail: string;
+    tone: StatusTone;
+    action: NextAction | null;
+};
+/** What kind of evidence problem a verdict records: a check the machine
+ * actually ran and saw fail, evidence that contradicts the sealed record
+ * (a mismatched changed-path claim, an altered criterion, a caveat that
+ * contradicts a met verdict), or evidence that is simply absent. A generic
+ * refuted verdict is NOT a failed test claim — only the verify-command
+ * reasons say a check failed. */
+export type EvidenceProblem = "checks-failed" | "mismatched" | "missing" | "none";
+export declare function evidenceProblemOf(verdict: ProofVerdict | null, reasons: readonly string[]): EvidenceProblem;
+/** The exit code of the failed check, when the recorded reason names one. */
+export declare function failedCheckExit(reasons: readonly string[]): number | null;
+/** The observed publication record in words. Each state is a distinct
+ * fact: a pushed branch is not a PR, an open PR is not a merge, and a
+ * merge is not a deployment — no record here ever says "deployed". The
+ * words name what was recorded or last observed and what stays
+ * unconfirmed; a missing or stale observation never proves that nothing
+ * merged or deployed, and merging is never called manual-only — an
+ * authorized mode may merge on green. */
+export declare function publicationStatusOf(publication: PublicationFacts): {
+    token: string;
+    label: string;
+    detail: string;
+} | null;
+/**
+ * The finished result's status — the one place the done words are chosen.
+ * Precedence: no record → scout report → operator acceptance → the machine
+ * verdict's problems (a refuted or short verdict is never masked by a
+ * no-change outcome) → a no-change conclusion, which owes no proof beyond
+ * its handoff and sealed diff → agent-attested → verified, where an
+ * observed publication names itself (a published but unverified result
+ * keeps its evidence problem as the main wording; the publication rides
+ * the detail).
+ */
+export declare function resultStatusOf(result: ResultFacts | null, publication?: PublicationFacts): DisplayStatus;
+/** The completion receipt's heading: what the record actually supports.
+ * Never "shipped" — local changes are saved; a PR or merge is named only
+ * from its observed record. */
+export declare function receiptHeadingOf(outcome: string | null, publication: PublicationFacts, role?: string | null): string;
+/** The receipt's one-line publication fact under the heading. */
+export declare function receiptPublicationWords(publication: PublicationFacts): string;
+/** Everything one Work row needs, gathered by the server from records it
+ * already reads elsewhere. */
+export type WorkFacts = {
+    id: string;
+    title: string;
+    repo: string | null;
+    state: TaskState;
+    updatedAt: string;
+    dispatch: DispatchDiagnosis | null;
+    result: ResultFacts | null;
+    publication: PublicationFacts;
+    liveRunId: number | null;
+    /** The unfinished recorded attempt, even if its claim disappeared. */
+    unfinishedRunId?: number | null;
+    control?: TaskControlView;
+    /** An unanswered question on this exact task, read from the decision
+     * owner. An elapsed attention deadline does not close a question. */
+    openDecision?: {
+        id: number;
+        runId: number;
+        question: string;
+        overdue: boolean;
+    } | null;
+};
+export type WorkStatus = DisplayStatus & {
+    /** Which shortcut views list this row; `all` always does. */
+    views: readonly WorkView[];
+    /** The rank All sorts by: what needs a person first, then live work,
+     * then queued and waiting, then finished, then cancelled. */
+    rank: number;
+    /** Facts that remain visible when a more useful next action leads. */
+    diagnostics?: readonly Pick<DisplayStatus, "token" | "label" | "detail" | "tone">[];
+};
+/** Needs you: the existing diagnosis semantics — waiting on a person with a
+ * concrete act — never every queued task indiscriminately. */
+export declare function needsPerson(dispatch: DispatchDiagnosis | null): boolean;
+export declare function dispatchActionLabel(dispatch: DispatchDiagnosis | null): string;
+export declare function workStatusOf(facts: WorkFacts, resultDisplay?: DisplayStatus): WorkStatus;
+/** The counts each view tab wears — from the same rows the page lists. */
+export declare function workCounts(rows: readonly {
+    views: readonly WorkView[];
+}[]): Record<WorkView, number>;
+/** All's order: rank, then most recently updated. */
+export declare function compareWorkRows(a: {
+    rank: number;
+    updatedAt: string;
+}, b: {
+    rank: number;
+    updatedAt: string;
+}): number;
+/** The shell's three primary destinations, from the page's own active
+ * key: every old page keeps its key and lights the destination it now
+ * lives under. */
+export type PrimaryDestination = "chat" | "work" | "projects" | "flows" | "settings" | null;
+export declare function primaryDestinationOf(active: string): PrimaryDestination;
+/** Learning stays in Settings and a useful, closed result disclosure. */
+export declare function learningHtml(view: import('./project-learning.js').LearningView, csrf: string, canManage: boolean, source?: number): string;