@litfamily/litopencode 1.0.20 → 1.0.22

package/dist/model-route-policy.js

@@ -1,8 +1,14 @@
 import { effectiveAgentConfig } from "./config.js";
-import { defaultOpenAiRoutes, newGenerationOpenAiModels, openAiModelEfforts, previousGenerationOpenAiModels, previousGpt6OpenAiModels, stripFastSuffix } from "./cli/model-catalog.js";
-const safeLunaEfforts = new Set(openAiModelEfforts(previousGenerationOpenAiModels.luna));
-const safeTerraEfforts = new Set(openAiModelEfforts(previousGenerationOpenAiModels.terra));
+import { defaultOpenAiRoutes, newGenerationOpenAiModels, openAiModelEfforts, previousGenerationOpenAiModels, previousGpt6OpenAiModels, replacedRetiredEffort, stripFastSuffix } from "./cli/model-catalog.js";
 const safeAstraEfforts = new Set(openAiModelEfforts(defaultOpenAiRoutes.lead.model));
+// The managed rows whose effort is checked; other GPT-5.6 ids stay user-owned as before.
+const guardedModels = new Set([
+    newGenerationOpenAiModels.sol,
+    previousGpt6OpenAiModels.sol,
+    newGenerationOpenAiModels.luna,
+    previousGenerationOpenAiModels.luna,
+    previousGenerationOpenAiModels.terra
+]);
 function dispatchedModel(route) {
     if (route.model === undefined)
         return undefined;
@@ -53,41 +59,17 @@ export function diagnoseModelRoutes(routes) {
             }
             continue;
         }
-        if (modelId === newGenerationOpenAiModels.sol || modelId === previousGpt6OpenAiModels.sol || modelId === newGenerationOpenAiModels.luna) {
-            const supported = new Set(openAiModelEfforts(modelId));
-            const variantUnsafe = route.variant !== undefined && !supported.has(route.variant);
-            const reasoningUnsafe = route.reasoningEffort !== undefined && !supported.has(route.reasoningEffort);
-            if (variantUnsafe || reasoningUnsafe || (route.variant === undefined && route.reasoningEffort === undefined)) {
-                diagnostics.push({ agentId, code: "model_effort_unsupported", model, effort });
-            }
-            if (route.variant !== undefined && route.reasoningEffort !== undefined && route.variant !== route.reasoningEffort) {
-                diagnostics.push({ agentId, code: "model_effort_conflict", model, effort });
-            }
-            continue;
-        }
-        if (modelId === previousGenerationOpenAiModels.luna) {
-            const hasXhigh = route.variant === "xhigh" || route.reasoningEffort === "xhigh";
-            if ((route.variant !== undefined && route.variant !== "xhigh" && !safeLunaEfforts.has(route.variant)) ||
-                (route.reasoningEffort !== undefined && route.reasoningEffort !== "xhigh" && !safeLunaEfforts.has(route.reasoningEffort)) ||
-                (route.variant === undefined && route.reasoningEffort === undefined)) {
-                diagnostics.push({ agentId, code: "luna_effort_below_high", model, effort });
-            }
-            if (hasXhigh)
-                diagnostics.push({ agentId, code: "luna_xhigh_forbidden", model, effort });
-            if (route.variant !== undefined && route.reasoningEffort !== undefined && route.variant !== route.reasoningEffort) {
-                diagnostics.push({ agentId, code: "luna_effort_conflict", model, effort });
-            }
+        // Each guarded row accepts exactly the efforts OpenCode offers for it.
+        if (!guardedModels.has(modelId))
             continue;
-        }
-        if (modelId !== previousGenerationOpenAiModels.terra)
-            continue;
-        if ((route.variant !== undefined && !safeTerraEfforts.has(route.variant)) ||
-            (route.reasoningEffort !== undefined && !safeTerraEfforts.has(route.reasoningEffort)) ||
-            (route.variant === undefined && route.reasoningEffort === undefined)) {
-            diagnostics.push({ agentId, code: "terra_effort_below_high", model, effort });
+        const supported = new Set(openAiModelEfforts(modelId));
+        const variantUnsafe = route.variant !== undefined && !supported.has(route.variant);
+        const reasoningUnsafe = route.reasoningEffort !== undefined && !supported.has(route.reasoningEffort);
+        if (variantUnsafe || reasoningUnsafe || (route.variant === undefined && route.reasoningEffort === undefined)) {
+            diagnostics.push({ agentId, code: "model_effort_unsupported", model, effort });
         }
         if (route.variant !== undefined && route.reasoningEffort !== undefined && route.variant !== route.reasoningEffort) {
-            diagnostics.push({ agentId, code: "terra_effort_conflict", model, effort });
+            diagnostics.push({ agentId, code: "model_effort_conflict", model, effort });
         }
     }
     return diagnostics;
@@ -114,22 +96,12 @@ export class UnsafeModelRouteError extends Error {
         const summary = diagnostics
             .map((diagnostic) => {
             switch (diagnostic.code) {
-                case "luna_effort_below_high":
-                    return `${diagnostic.agentId}: Luna requires high or max (${diagnostic.model}, ${diagnostic.effort})`;
-                case "luna_xhigh_forbidden":
-                    return `${diagnostic.agentId}: Luna plus xhigh is forbidden (${diagnostic.model}, ${diagnostic.effort})`;
-                case "luna_effort_conflict":
-                    return `${diagnostic.agentId}: Luna effort fields conflict (${diagnostic.model}, ${diagnostic.effort})`;
-                case "terra_effort_below_high":
-                    return `${diagnostic.agentId}: TERRA requires high or xhigh (${diagnostic.model}, ${diagnostic.effort})`;
-                case "terra_effort_conflict":
-                    return `${diagnostic.agentId}: TERRA effort fields conflict (${diagnostic.model}, ${diagnostic.effort})`;
                 case "astra_effort_unsupported":
-                    return `${diagnostic.agentId}: Astra requires low, medium, high, xhigh, or max (${diagnostic.model}, ${diagnostic.effort})`;
+                    return `${diagnostic.agentId}: Astra requires ${[...safeAstraEfforts].join(", ")} (${diagnostic.model}, ${diagnostic.effort})`;
                 case "astra_effort_conflict":
                     return `${diagnostic.agentId}: Astra effort fields conflict (${diagnostic.model}, ${diagnostic.effort})`;
                 case "model_effort_unsupported":
-                    return `${diagnostic.agentId}: ${diagnostic.model} accepts a supported catalog effort (${diagnostic.model}, ${diagnostic.effort})`;
+                    return `${diagnostic.agentId}: ${diagnostic.model} accepts ${openAiModelEfforts(unqualifiedModel(diagnostic.model)).join(", ")} (${diagnostic.model}, ${diagnostic.effort})`;
                 case "model_effort_conflict":
                     return `${diagnostic.agentId}: ${diagnostic.model} effort fields conflict (${diagnostic.model}, ${diagnostic.effort})`;
             }
@@ -144,3 +116,30 @@ export function assertSafeEffectiveAgentRoutes(config, agentIds) {
     if (diagnostics.length > 0)
         throw new UnsafeModelRouteError(diagnostics);
 }
+function isRouteRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The saved routes in a litopencode.json object that still name an effort OpenCode no longer offers. */
+export function retiredEffortRoutes(config) {
+    const found = [];
+    if (!isRouteRecord(config))
+        return found;
+    for (const section of ["categories", "agents"]) {
+        const entries = config[section];
+        if (!isRouteRecord(entries))
+            continue;
+        for (const [id, route] of Object.entries(entries)) {
+            if (!isRouteRecord(route) || typeof route.model !== "string")
+                continue;
+            const provider = typeof route.provider === "string" ? route.provider : undefined;
+            const effort = (value) => (typeof value === "string" ? value : undefined);
+            if (replacedRetiredEffort(provider, route.model, effort(route.variant)) === undefined && replacedRetiredEffort(provider, route.model, effort(route.reasoningEffort)) === undefined)
+                continue;
+            found.push({ section, id, model: route.model.slice(route.model.indexOf("/") + 1) });
+        }
+    }
+    return found;
+}
+export function retiredEffortWarning(route) {
+    return `ultra is no longer offered by OpenCode for ${route.model} (${route.section}.${route.id}); the next install moves it to max.`;
+}

package/dist/tui/mission-band.d.ts

@@ -11,6 +11,17 @@ export type BandOptions = {
  * `band: { card: true }` adds the detail card under the status card. Anything else keeps the defaults.
  */
 export declare function readBandOptions(options: unknown): BandOptions;
+export type NotifyOptions = {
+    readonly enabled: boolean;
+    readonly desktop: boolean;
+    readonly sound: boolean;
+};
+/**
+ * Reads the finish alert switch from the plugin's tui.json options. It is off unless `notify` is true
+ * (desktop notification and the host's `done` sound) or an object that turns either part off with
+ * `desktop: false` or `sound: false`.
+ */
+export declare function readNotifyOptions(options: unknown): NotifyOptions;
 /**
  * The skill chips row, exactly `width` cells: bright accent pills for the current request first, then
  * dim recent names, and `+N` for the ones that do not fit. The label goes before any chip does.
@@ -25,6 +36,8 @@ export type CardInputs = {
     readonly view: MissionView;
     readonly frame: MotionFrame;
     readonly chips: readonly SkillChip[];
+    /** Whether the session's turn is running; false lets a lit card rest at idle. Unknown keeps it working. */
+    readonly busy?: boolean;
     readonly shimmer?: ChipShimmer;
     readonly figures: CardFigures;
     /** The project's last goal, shown on the track while the session has no lit mission. */

package/dist/tui/mission-band.js

@@ -4,8 +4,8 @@
 // It reuses the chip's pills, the panel's bar and the shared motion frame, so the chip, the panel and
 // the band always move together.
 import { ease, mixHex, motionTiming, seg } from "./mission-motion.js";
-import { contextWarnPercent, missionStatus } from "./mission-model.js";
-import { cellWidth, chipSparkCells, chipSparkWidth, fade, lineWidth, missionPanel, progressBar, shimmerAt, shine, statusSegments, stepPill, truncateCells } from "./mission-text.js";
+import { contextWarnPercent, currentStepIndex, missionStatus, stepName } from "./mission-model.js";
+import { cellWidth, chipSparkCells, chipSparkWidth, crumb, fade, lineWidth, linkColor, liveSegments, missionPanel, progressBar, shimmerAt, shine, stageFlash, statusSegments, truncateCells } from "./mission-text.js";
 /**
  * Reads the band switches from the plugin's tui.json options: `band: false` turns the band off,
  * `band: { card: true }` adds the detail card under the status card. Anything else keeps the defaults.
@@ -17,12 +17,31 @@ export function readBandOptions(options) {
     const card = typeof band === "object" && band !== null && band.card === true;
     return { enabled: true, card };
 }
+/**
+ * Reads the finish alert switch from the plugin's tui.json options. It is off unless `notify` is true
+ * (desktop notification and the host's `done` sound) or an object that turns either part off with
+ * `desktop: false` or `sound: false`.
+ */
+export function readNotifyOptions(options) {
+    const notify = typeof options === "object" && options !== null ? options.notify : undefined;
+    if (notify === true)
+        return { enabled: true, desktop: true, sound: true };
+    if (typeof notify !== "object" || notify === null)
+        return { enabled: false, desktop: false, sound: false };
+    const record = notify;
+    const desktop = record.desktop !== false;
+    const sound = record.sound !== false;
+    return { enabled: desktop || sound, desktop, sound };
+}
 const minimumText = 12;
 function elapsedText(minutes) {
     const total = Math.max(0, minutes ?? 0);
     return total < 60 ? `${total}m` : `${Math.floor(total / 60)}h${String(total % 60).padStart(2, "0")}`;
 }
-/** The text after the bar: a warning (⚑ and words) replaces the next task; a finished mission shows COMPLETE. */
+/**
+ * The text after the bar: a warning (⚑ and words) replaces the live step and the next task; a finished
+ * mission shows COMPLETE. Otherwise the live step, then the next task when it still has room.
+ */
 function trailing(view, frame, palette, room) {
     if (view.complete) {
         // Before COMPLETE pops in, the slot stays empty rather than flashing the header's "● active".
@@ -37,9 +56,12 @@ function trailing(view, frame, palette, room) {
         const color = warning.kind === "retry" ? mixHex(palette.warning, palette.error, 0.5) : palette.warning;
         return [{ text: "  ⚑ ", fg: color, bold: true }, { text: truncateCells(warning.text, room - 4), fg: color }];
     }
-    if (view.next === undefined)
-        return [];
-    return [{ text: "  ▸ ", fg: palette.muted }, { text: truncateCells(view.next, room - 4), fg: palette.text }];
+    const live = liveSegments(view, frame, palette, Math.min(28, room - 2));
+    const lead = live.length === 0 ? [] : [{ text: "  ", fg: palette.muted }, ...live];
+    const left = room - lineWidth(lead);
+    if (view.next === undefined || left < minimumText)
+        return lead;
+    return [...lead, { text: "  ▸ ", fg: palette.muted }, { text: truncateCells(view.next, left - 4), fg: palette.text }];
 }
 /** Cuts or pads a line to exactly `width` cells, keeping wide glyphs whole. */
 function fitLine(line, width, palette) {
@@ -82,28 +104,35 @@ function ruled(lead, left, right, tail, width, border) {
         return undefined;
     return [{ text: lead, fg: border }, ...l, { text: "─".repeat(fill), fg: border }, ...r, { text: tail, fg: border }];
 }
-function borderColor(view, frame, palette) {
-    if (!view.active)
+/**
+ * A lit session whose turn has ended rests: nothing is running, so the card stops showing a lit step.
+ * A finished goal and an open warning still show, since they are news after the turn.
+ */
+function resting(view, busy) {
+    return view.active && busy === false && !view.complete && view.warnings.length === 0;
+}
+function borderColor(view, frame, palette, rest) {
+    if (!view.active || rest)
         return palette.borderActive;
     const enter = frame.chipEnter ? ease.outCubic(seg(frame.t, 0, motionTiming.entry)) : 1;
     const done = view.complete ? (frame.celebrate === undefined ? 1 : ease.inOutCubic(seg(frame.celebrate, 0, motionTiming.crossfade))) : 0;
     return mixHex(palette.borderActive, mixHex(mixHex(palette.accent, palette.warning, frame.warn), palette.success, done), enter);
 }
 /** The phase on the right of the title: always a glyph plus words. */
-function phaseLabel(view, frame, palette) {
-    if (!view.active)
+function phaseLabel(view, frame, palette, rest) {
+    if (!view.active || rest)
         return { text: "○ IDLE", fg: palette.muted };
     const status = missionStatus(view);
     if (status.tone === "success")
         return { text: "✓ COMPLETE", fg: palette.success, bold: true };
     if (status.tone === "warning")
         return { text: `⚑ ${status.text}`, fg: mixHex(palette.info, palette.warning, Math.max(frame.warn, 0.5)), bold: true };
-    return { text: `● ${view.phase.toUpperCase()}`, fg: palette.info, bold: true };
+    return { text: `● ${stepName(view.phase, view).toUpperCase()}`, fg: palette.info, bold: true };
 }
-function topLine(view, frame, palette, width, border) {
+function topLine(view, frame, palette, width, border, rest) {
     const brand = [{ text: "🔥 ", fg: palette.text }, { text: "LIT", fg: shine(palette.primary, palette, 0.5, shimmerAt(frame), 0.6), bold: true }];
     const name = view.active ? view.discipline : "ready";
-    const right = [phaseLabel(view, frame, palette)];
+    const right = [phaseLabel(view, frame, palette, rest)];
     const withName = (room) => [...brand, { text: " · ", fg: palette.muted }, { text: truncateCells(name, room), fg: view.active ? palette.text : palette.muted }];
     const nameRoom = width - cellWidth("╭─") - lineWidth(withName(0)) - 2 - (lineWidth(right) + 2) - cellWidth("─╮") - 1;
     const attempts = [];
@@ -141,17 +170,22 @@ function bottomLine(view, figures, palette, width, border) {
     }
     return fitLine([{ text: "╰" + "─".repeat(Math.max(0, width)), fg: border }], width, palette);
 }
+/** The whole stage map as a breadcrumb, `plan ✓ ━ WORK 1/3 ─ review ─ done`, or only the running stage when tight. */
 function trackPills(view, frame, palette, tight) {
     const alpha = (index) => (frame.chipEnter ? ease.outCubic(seg(frame.t, index * motionTiming.stagger, motionTiming.entry)) : 1);
-    if (tight) {
-        const current = view.steps.find((step) => step.state === "now" || step.state === "warn") ?? view.steps[view.complete ? 2 : view.active ? 1 : 0];
-        return [fade(stepPill(current, view, frame, palette), alpha(0), palette)];
-    }
+    const reached = currentStepIndex(view);
+    const current = Math.min(view.steps.length - 1, Math.max(0, reached));
+    const flash = stageFlash(frame);
+    if (tight)
+        return crumb(view, current, frame, palette, 0, flash).map((segment) => fade(segment, alpha(0), palette));
     const out = [];
-    view.steps.forEach((step, index) => {
-        if (index > 0)
-            out.push(fade({ text: " ━ ", fg: view.steps[index - 1].state === "done" ? palette.success : palette.borderSubtle }, alpha(index), palette));
-        out.push(fade(stepPill(step, view, frame, palette), alpha(index), palette));
+    view.steps.forEach((_step, index) => {
+        if (index > 0) {
+            const color = linkColor(view, index, frame, palette, palette.borderSubtle);
+            out.push(fade({ text: color === palette.borderSubtle ? " ─ " : " ━ ", fg: color }, alpha(index), palette));
+        }
+        for (const segment of crumb(view, index, frame, palette, 0, index === current && reached >= 0 ? flash : -1))
+            out.push(fade(segment, alpha(index), palette));
     });
     return out;
 }
@@ -179,7 +213,8 @@ function trackRow(view, frame, palette, width, last) {
     for (const plan of trackPlans) {
         const pills = trackPills(view, frame, palette, plan.tight);
         const bar = plan.bar > 0 && view.progress !== undefined ? [gap, ...progressBar(frame.barRatio, plan.bar, palette, sweep)] : [];
-        const goal = view.goal;
+        // In the criterion loop the stage itself counts criteria, so the count is not repeated.
+        const goal = view.family === "loop" ? undefined : view.goal;
         const criteria = plan.criteria && goal !== undefined ? [gap, { text: `${goal.passed}/${goal.total} criteria`, fg: goal.total > 0 && goal.passed === goal.total ? palette.success : palette.muted }] : [];
         const fixed = lineWidth(pills) + lineWidth(bar) + lineWidth(criteria);
         if (fixed > width)
@@ -245,12 +280,15 @@ export function skillRow(chips, shimmer, palette, width) {
  * the prompt never moves. Each row sheds its own low-priority parts as the terminal narrows.
  */
 export function statusCard(input, palette, width) {
-    const { view, frame } = input;
-    const border = borderColor(view, frame, palette);
+    const { frame } = input;
+    const rest = resting(input.view, input.busy);
+    // At rest the track keeps what is done and unlights the step that was running.
+    const view = rest ? { ...input.view, steps: input.view.steps.map((step) => (step.state === "now" ? { ...step, state: "todo" } : step)) } : input.view;
+    const border = borderColor(view, frame, palette, rest);
     const inner = width - 4;
     const row = (content) => (inner < 0 ? fitLine([], width, palette) : [{ text: "│ ", fg: border }, ...fitLine(content, inner, palette), { text: " │", fg: border }]);
     return [
-        topLine(view, frame, palette, width, border),
+        topLine(view, frame, palette, width, border, rest),
         row(trackRow(view, frame, palette, Math.max(0, inner), input.last)),
         row(skillRow(input.chips, input.shimmer, palette, Math.max(0, inner))),
         bottomLine(view, input.figures, palette, width, border)

package/dist/tui/mission-model.d.ts

@@ -9,6 +9,34 @@ export type TodoInput = {
     readonly content: string;
     readonly status: string;
 };
+/** The plan file's `- [ ]` / `- [x]` rows: how many are ticked, how many exist, and the first open one. */
+export type PlanChecklist = {
+    readonly done: number;
+    readonly total: number;
+    readonly next?: string;
+};
+/** This session's bounded work from work-schema-3.json: its status, recorded progress turns and plan. */
+export type WorkInput = {
+    readonly status: string;
+    readonly iterations: number;
+    readonly plan?: PlanChecklist;
+};
+export type ResearchStage = "decompose" | "wave" | "expand" | "verify" | "synthesis";
+/** The latest litresearch run folder: what its journal, claim graph and report say so far. */
+export type ResearchInput = {
+    readonly stage: ResearchStage;
+    readonly waves: number;
+    readonly claims: number;
+    readonly verified: number;
+    readonly reported: boolean;
+    /** Last write to the run folder, in ms; a run older than the session's first lit turn is earlier work. */
+    readonly touchedAt: number;
+};
+/** The tool the session is running now: its name and start time only, never its input. */
+export type LiveStep = {
+    readonly tool: string;
+    readonly start: number;
+};
 export type MissionInput = {
     readonly marks: readonly LitMark[];
     readonly agent?: string;
@@ -19,9 +47,17 @@ export type MissionInput = {
     readonly pendingPermissions?: number;
     readonly pendingQuestions?: number;
     readonly contextPercent?: number | null;
+    readonly work?: WorkInput;
+    readonly research?: ResearchInput;
+    readonly live?: LiveStep;
     readonly now: number;
 };
-export type StepId = "plan" | "work" | "review";
+/**
+ * Which stage table the map follows: the main chain, lit-loop's criterion loop (the same stages with
+ * the work stage counting criteria), or a litresearch run.
+ */
+export type MissionFamily = "main" | "loop" | "research";
+export type StepId = "interview" | "plan" | "work" | "review" | "done" | ResearchStage;
 export type StepState = "done" | "skip" | "now" | "todo" | "warn";
 export type MissionStep = {
     readonly id: StepId;
@@ -50,13 +86,22 @@ export type MissionEvent = {
 export type MissionView = {
     readonly active: boolean;
     readonly discipline: string;
-    readonly phase: StepId | "done";
+    readonly family: MissionFamily;
+    readonly phase: StepId;
     readonly steps: readonly MissionStep[];
     readonly progress?: {
         readonly done: number;
         readonly total: number;
     };
     readonly next?: string;
+    /** The lead of the detail line: `task 3`, or a research run's claim counts. */
+    readonly detail?: string;
+    /** Recorded turns of the current loop: bounded work progress, or lit-loop goal checkpoints. */
+    readonly iteration?: number;
+    /** How many tasks the saved plan holds, shown beside the plan stage. */
+    readonly planTasks?: number;
+    readonly wave?: number;
+    readonly live?: LiveStep;
     readonly goal?: MissionGoal;
     readonly blockers: readonly {
         readonly id: string;
@@ -77,9 +122,28 @@ export type MissionNotice = {
     readonly celebrate?: boolean;
 };
 export declare const contextWarnPercent = 75;
+export declare const familySteps: Readonly<Record<MissionFamily, readonly StepId[]>>;
 export declare const idleMission: MissionView;
 /** Reads one part's `metadata.litopencode` mark. Anything without that shape is not a mark. */
 export declare function readLitMark(metadata: unknown, at: number): LitMark | undefined;
+/** The name a stage shows: the loop counts criteria at its work stage and a research wave carries its number. */
+export declare function stepName(id: StepId, view: Pick<MissionView, "family" | "wave">): string;
+/** Index of the stage that is running (or flagged); the step count once complete; -1 while idle. */
+export declare function currentStepIndex(view: Pick<MissionView, "steps" | "complete" | "active">): number;
+/**
+ * Counts a plan's checkbox rows at column zero (`- [ ] 1. title — …`). The first open row, cut at its
+ * em dash, becomes the next item. Indented rows are not tasks.
+ */
+export declare function planChecklist(text: string): PlanChecklist | undefined;
+/**
+ * Lenient read of work-schema-3.json for one session: undefined when it is absent, another session's,
+ * cancelled, or not the schema-3 shape. Iterations count the recorded `work.progressed` turns.
+ */
+export declare function readWorkState(raw: unknown, sessionID: string): {
+    readonly status: string;
+    readonly iterations: number;
+    readonly planPath: string;
+} | undefined;
 type LedgerCriterion = {
     readonly id: string;
     readonly scenario: string;
@@ -106,8 +170,10 @@ type LedgerGoal = {
         readonly resolved: boolean;
         readonly needsUserDecision: boolean;
     }[];
+    /** Written by the ledger CLI, whose completion gate checks evidence; a hand-written goal passed none. */
+    readonly gated: boolean;
 };
-/** Lenient read of goals.json: the active goal, or undefined when the file is absent or not the ledger shape. */
+/** Lenient read of goals.json: the goal it names, or undefined when there is none. */
 export declare function readActiveGoal(raw: unknown): LedgerGoal | undefined;
 export declare function formatAgo(at: string, now: number): string;
 export declare function buildMissionView(input: MissionInput): MissionView;