@litfamily/litopencode 1.0.18 → 1.0.19

package/dist/tui/mission-model.js

@@ -0,0 +1,318 @@
+// The mission view model for the OpenCode TUI. It reads only what LitOpenCode already leaves behind:
+// the `metadata.litopencode` marks the plugin attaches to user-message parts on activation and on
+// commands, the host todo list, and the evidence ledger in .litopencode/litgoal/lit-loop/goals.json.
+// No new state is written for the TUI.
+export const contextWarnPercent = 75;
+const timelineLimit = 4;
+const staleGoalSlackMs = 60_000;
+export const idleMission = Object.freeze({
+    active: false,
+    discipline: "",
+    phase: "plan",
+    steps: Object.freeze([
+        { id: "plan", state: "todo" },
+        { id: "work", state: "todo" },
+        { id: "review", state: "todo" }
+    ]),
+    blockers: Object.freeze([]),
+    warnings: Object.freeze([]),
+    timeline: Object.freeze([]),
+    planSaved: false,
+    complete: false
+});
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === "string" ? value : "";
+}
+/** Reads one part's `metadata.litopencode` mark. Anything without that shape is not a mark. */
+export function readLitMark(metadata, at) {
+    if (!isRecord(metadata) || !isRecord(metadata.litopencode))
+        return undefined;
+    const mark = metadata.litopencode;
+    const mode = text(mark.mode);
+    const command = text(mark.command);
+    if (mode === "" && command === "")
+        return undefined;
+    return {
+        at,
+        ...(mode === "" ? {} : { mode }),
+        ...(command === "" ? {} : { command }),
+        ...(text(mark.operation) === "" ? {} : { operation: text(mark.operation) }),
+        ...(mark.blocked === true ? { blocked: true } : {})
+    };
+}
+function stepOf(name) {
+    if (name === "")
+        return undefined;
+    if (name === "review-work" || name.includes("review"))
+        return "review";
+    if (name === "lit-plan" || name.endsWith("-plan") || name === "lit-crucible" || name === "deep-interview")
+        return "plan";
+    return "work";
+}
+/** Lenient read of goals.json: the active goal, or undefined when the file is absent or not the ledger shape. */
+export function readActiveGoal(raw) {
+    if (!isRecord(raw) || !Array.isArray(raw.goals))
+        return undefined;
+    const goal = raw.goals.find((candidate) => isRecord(candidate) && candidate.id === raw.activeGoalId);
+    if (!isRecord(goal))
+        return undefined;
+    const list = (value) => (Array.isArray(value) ? value.filter(isRecord) : []);
+    return {
+        title: text(goal.title) || text(goal.objective),
+        status: text(goal.status),
+        createdAt: text(goal.createdAt),
+        updatedAt: text(goal.updatedAt),
+        criteria: list(goal.criteria).map((criterion) => ({
+            id: text(criterion.id),
+            scenario: text(criterion.scenario),
+            status: text(criterion.status),
+            evidence: list(criterion.evidence).map((entry) => ({ kind: text(entry.kind), ref: text(entry.ref), at: text(entry.at) }))
+        })),
+        checkpoints: list(goal.checkpoints).map((entry) => ({ summary: text(entry.summary), at: text(entry.at) })),
+        reviewBlockers: list(goal.reviewBlockers).map((entry) => ({
+            id: text(entry.id),
+            detail: text(entry.detail),
+            resolved: entry.resolved === true,
+            needsUserDecision: entry.needsUserDecision === true
+        }))
+    };
+}
+export function formatAgo(at, now) {
+    const time = Date.parse(at);
+    if (!Number.isFinite(time))
+        return "";
+    const seconds = Math.max(0, Math.round((now - time) / 1000));
+    if (seconds < 60)
+        return "now";
+    const minutes = Math.round(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return `${hours}h`;
+    return `${Math.round(hours / 24)}d`;
+}
+function timeline(goal, now) {
+    const events = [];
+    for (const criterion of goal.criteria) {
+        for (const entry of criterion.evidence) {
+            events.push({ at: Date.parse(entry.at), raw: entry.at, kind: entry.kind, label: `${criterion.id} ${entry.ref}`.trim() });
+        }
+    }
+    for (const checkpoint of goal.checkpoints) {
+        events.push({ at: Date.parse(checkpoint.at), raw: checkpoint.at, kind: "checkpoint", label: checkpoint.summary });
+    }
+    if (goal.createdAt !== "")
+        events.push({ at: Date.parse(goal.createdAt), raw: goal.createdAt, kind: "goal", label: "created" });
+    return events
+        .filter((event) => Number.isFinite(event.at))
+        .sort((left, right) => right.at - left.at)
+        .slice(0, timelineLimit)
+        .map((event) => ({ ago: formatAgo(event.raw, now), kind: event.kind, label: event.label }));
+}
+export function buildMissionView(input) {
+    const marks = [...input.marks].sort((left, right) => left.at - right.at);
+    const agentStep = input.agent?.startsWith("lit-") === true ? stepOf(input.agent) : undefined;
+    const latest = marks.at(-1);
+    // The ledger is per project. A goal last touched before this session's first lit turn belongs to
+    // earlier work, so a fresh session does not open on someone else's finished goal.
+    const ledgerGoal = readActiveGoal(input.ledger);
+    const touched = ledgerGoal === undefined ? Number.NaN : Date.parse(ledgerGoal.updatedAt || ledgerGoal.createdAt);
+    const goal = ledgerGoal !== undefined && marks.length > 0 && !(touched < marks[0].at - staleGoalSlackMs) ? ledgerGoal : undefined;
+    // lit-loop is LitOpenCode's default agent, so the agent alone never lights the mission; only a lit
+    // activation or a lit command recorded in this session does.
+    const active = marks.length > 0;
+    if (!active)
+        return idleMission;
+    const planMark = [...marks].reverse().find((mark) => mark.operation === "save-plan");
+    const planSaved = planMark !== undefined && planMark.blocked !== true;
+    const planBlocked = planMark?.blocked === true;
+    const discipline = latest?.mode && latest.mode !== "bounded-authority-lifecycle" ? latest.mode : latest?.command ?? input.agent ?? "lit";
+    const counted = input.todos.filter((todo) => todo.status !== "cancelled");
+    const progress = counted.length > 0
+        ? { done: counted.filter((todo) => todo.status === "completed").length, total: counted.length }
+        : goal !== undefined && goal.criteria.length > 0
+            ? { done: goal.criteria.filter((criterion) => criterion.status === "pass").length, total: goal.criteria.length }
+            : undefined;
+    const nextTodo = counted.find((todo) => todo.status === "in_progress") ?? counted.find((todo) => todo.status === "pending");
+    const nextCriterion = goal?.criteria.find((criterion) => criterion.status !== "pass");
+    const blockers = (goal?.reviewBlockers ?? []).filter((blocker) => !blocker.resolved);
+    const complete = goal?.status === "complete" || (progress !== undefined && progress.total > 0 && progress.done === progress.total && goal === undefined && counted.length > 0);
+    let phase = latest === undefined ? agentStep ?? "work" : stepOf(latest.command ?? latest.mode ?? "") ?? "work";
+    if (latest?.operation === "save-plan" && !planBlocked)
+        phase = "work";
+    // A blocker sends finished work back to review; with criteria still open the work phase carries the warning.
+    const workComplete = progress === undefined || progress.done === progress.total;
+    if (blockers.length > 0 || goal?.status === "review_blocked")
+        phase = workComplete ? "review" : phase === "review" ? "review" : "work";
+    if (complete)
+        phase = "done";
+    const warnings = [];
+    for (const blocker of blockers) {
+        warnings.push({ kind: blocker.needsUserDecision ? "decision" : "blocker", text: `${blocker.id} ${blocker.detail}`.trim() });
+    }
+    if (goal?.status === "needs_user_decision" && !blockers.some((blocker) => blocker.needsUserDecision)) {
+        warnings.push({ kind: "decision", text: "goal needs your decision" });
+    }
+    if (planBlocked && phase === "plan")
+        warnings.push({ kind: "plan", text: "plan not saved yet" });
+    if (input.sessionStatus === "retry")
+        warnings.push({ kind: "retry", text: input.retryMessage ? `retrying · ${input.retryMessage}` : "retrying" });
+    if ((input.pendingPermissions ?? 0) > 0)
+        warnings.push({ kind: "permission", text: "waiting for permission" });
+    if ((input.pendingQuestions ?? 0) > 0)
+        warnings.push({ kind: "question", text: "waiting for your answer" });
+    if (typeof input.contextPercent === "number" && input.contextPercent >= contextWarnPercent) {
+        warnings.push({ kind: "context", text: `ctx ${Math.round(input.contextPercent)}%` });
+    }
+    const order = ["plan", "work", "review"];
+    const position = phase === "done" ? order.length : order.indexOf(phase);
+    const planned = planMark !== undefined || agentStep === "plan" || marks.some((mark) => stepOf(mark.command ?? mark.mode ?? "") === "plan");
+    const steps = order.map((id, index) => {
+        if (index < position)
+            return { id, state: id === "plan" && !planned ? "skip" : "done" };
+        if (index > position)
+            return { id, state: "todo" };
+        return { id, state: warnings.length > 0 ? "warn" : "now" };
+    });
+    return {
+        active: true,
+        discipline,
+        phase,
+        steps,
+        ...(progress === undefined ? {} : { progress }),
+        ...(nextTodo !== undefined ? { next: nextTodo.content } : nextCriterion !== undefined ? { next: `${nextCriterion.id} ${nextCriterion.scenario}`.trim() } : {}),
+        ...(goal === undefined
+            ? {}
+            : {
+                goal: {
+                    title: goal.title,
+                    status: goal.status,
+                    passed: goal.criteria.filter((criterion) => criterion.status === "pass").length,
+                    total: goal.criteria.length,
+                    criteria: goal.criteria.map((criterion) => ({ id: criterion.id, status: criterion.status }))
+                }
+            }),
+        blockers: blockers.map((blocker) => ({ id: blocker.id, detail: blocker.detail, needsUserDecision: blocker.needsUserDecision })),
+        warnings,
+        timeline: goal === undefined ? [] : timeline(goal, input.now),
+        planSaved,
+        complete,
+        elapsedMinutes: Math.max(0, Math.floor((input.now - marks[0].at) / 60_000))
+    };
+}
+const noticeRank = { error: 3, warning: 2, success: 1, info: 0 };
+/**
+ * OpenCode shows one toast at a time, so several gate events from one refresh collapse into the most
+ * urgent one (completion first), with the rest counted in its message. The panel still lists them all.
+ */
+export function leadingNotice(notices) {
+    if (notices.length <= 1)
+        return notices[0];
+    const lead = [...notices].sort((left, right) => Number(right.celebrate === true) - Number(left.celebrate === true) || noticeRank[right.variant] - noticeRank[left.variant])[0];
+    return { ...lead, message: `${lead.message} · +${notices.length - 1} more` };
+}
+/** The gate events between two views. A first view never toasts its whole history. */
+export function missionNotices(prev, next) {
+    if (prev === undefined || !next.active)
+        return [];
+    const notices = [];
+    if (prev.active && !prev.planSaved && next.planSaved) {
+        notices.push({ variant: "success", title: "🔥 Plan saved", message: "Work can start from the saved plan." });
+    }
+    if (!prev.warnings.some((warning) => warning.kind === "plan") && next.warnings.some((warning) => warning.kind === "plan")) {
+        notices.push({ variant: "warning", title: "🔥 Plan not saved yet", message: "Save the plan under .litopencode/plans before work starts." });
+    }
+    if (prev.goal === undefined && next.goal !== undefined) {
+        notices.push({ variant: "info", title: "🔥 Goal set", message: `${next.goal.title} · ${next.goal.total} criteria` });
+    }
+    if (prev.goal !== undefined && next.goal !== undefined) {
+        for (const criterion of next.goal.criteria) {
+            const before = prev.goal.criteria.find((candidate) => candidate.id === criterion.id);
+            if (criterion.status === "pass" && before?.status !== "pass") {
+                notices.push({ variant: "success", title: `✓ ${criterion.id} passed`, message: `${next.goal.passed}/${next.goal.total} criteria` });
+            }
+        }
+    }
+    for (const blocker of next.blockers) {
+        if (!prev.blockers.some((candidate) => candidate.id === blocker.id)) {
+            notices.push({
+                variant: "warning",
+                title: blocker.needsUserDecision ? "⚑ Needs your decision" : "⚑ Review blocker",
+                message: `${blocker.id} ${blocker.detail}`.trim()
+            });
+        }
+    }
+    for (const blocker of prev.blockers) {
+        if (!next.blockers.some((candidate) => candidate.id === blocker.id)) {
+            notices.push({ variant: "info", title: `✓ ${blocker.id} resolved`, message: blocker.detail });
+        }
+    }
+    if (!prev.complete && next.complete) {
+        const message = next.goal !== undefined
+            ? `${next.goal.title} · ${next.goal.passed}/${next.goal.total} criteria`
+            : `${next.progress?.done ?? 0}/${next.progress?.total ?? 0} tasks`;
+        notices.push({ variant: "success", title: "🔥 Complete", message, celebrate: true });
+    }
+    return notices;
+}
+const warningStatus = {
+    blocker: "review blocked",
+    decision: "needs decision",
+    retry: "retrying",
+    permission: "permission asked",
+    question: "question asked",
+    context: "context high",
+    plan: "plan not saved"
+};
+/** The short status beside the header: always a glyph plus words, never colour alone. */
+export function missionStatus(view) {
+    if (view.complete)
+        return { glyph: "✓", text: "COMPLETE", tone: "success" };
+    const warning = view.warnings[0];
+    if (warning !== undefined)
+        return { glyph: "⚑", text: warning.kind === "context" ? warning.text : warningStatus[warning.kind], tone: "warning" };
+    return { glyph: "●", text: view.goal === undefined ? "working" : "active", tone: "info" };
+}
+/**
+ * Stable keys for the panel rows a view shows. Motion compares two views' keys to decide which rows
+ * slide in, so a new goal animates its own rows without replaying the header.
+ */
+export function missionRowKeys(view) {
+    if (!view.active)
+        return [];
+    const keys = ["h1", "h2", "b1"];
+    if (view.goal !== undefined)
+        keys.push("title");
+    keys.push("steps");
+    if (view.progress !== undefined)
+        keys.push("bar");
+    const detail = (view.next !== undefined && !view.complete) || view.goal !== undefined || view.warnings.length > 0;
+    if (detail)
+        keys.push("b2");
+    if (view.next !== undefined && !view.complete)
+        keys.push("next");
+    if (view.goal !== undefined)
+        keys.push("crit");
+    view.warnings.forEach((warning) => keys.push(`warn:${warning.kind}:${warning.text}`));
+    if (view.timeline.length > 0) {
+        keys.push("b3", "evh");
+        view.timeline.forEach((_event, index) => keys.push(`ev${index}`));
+    }
+    return keys;
+}
+/** The project's last goal for the home line, or undefined when the ledger holds none. */
+export function lastMission(raw) {
+    const goal = readActiveGoal(raw);
+    if (goal === undefined || goal.title === "")
+        return undefined;
+    return {
+        title: goal.title,
+        passed: goal.criteria.filter((criterion) => criterion.status === "pass").length,
+        total: goal.criteria.length,
+        complete: goal.status === "complete"
+    };
+}

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

@@ -0,0 +1,66 @@
+import { type MissionView } from "./mission-model.ts";
+export declare const motionTiming: Readonly<{
+    stagger: 60;
+    entry: 160;
+    entryLead: 40;
+    fill: 300;
+    fillDelayOnGoal: 240;
+    noticeIn: 220;
+    crossfade: 140;
+    workDoneAt: 200;
+    reviewDoneAt: 260;
+    popAt: 300;
+    pop: 160;
+    shimmerAt: 300;
+    shimmer: 400;
+    settleAt: 1000;
+    complete: 1200;
+    frameMs: 33;
+}>;
+export declare function clamp01(value: number): number;
+export declare const ease: Readonly<{
+    outCubic: (x: number) => number;
+    inCubic: (x: number) => number;
+    inOutCubic: (x: number) => number;
+    outBack: (x: number) => number;
+}>;
+/** 0..1 progress of a track that starts `start` ms after the change and lasts `duration` ms. */
+export declare function seg(t: number, start: number, duration: number): number;
+/** Cells a row is pushed right while it slides in; the ease-out-back overshoot lands it a cell left first. */
+export declare function slideIn(progress: number, amplitude?: number): number;
+export declare function mixHex(from: string, to: string, t: number): string;
+export type MotionState = {
+    /** When the last state change happened; undefined while nothing has animated yet. */
+    readonly changeAt?: number;
+    /** Panel row keys that are new in this change and slide in, in order. */
+    readonly entering: readonly string[];
+    readonly chipEnter: boolean;
+    readonly barFrom: number;
+    readonly barTo: number;
+    readonly barDelay: number;
+    readonly warnFrom: number;
+    readonly warnTo: number;
+    readonly celebrate: boolean;
+};
+export type MotionFrame = {
+    /** Milliseconds since the last change; Infinity once settled or when motion is off. */
+    readonly t: number;
+    readonly entering: readonly string[];
+    readonly chipEnter: boolean;
+    readonly barRatio: number;
+    /** 0 = normal colours, 1 = warning colours. */
+    readonly warn: number;
+    /** Milliseconds into the completion moment while it plays, otherwise undefined. */
+    readonly celebrate?: number;
+    readonly moving: boolean;
+};
+export declare const idleMotion: MotionState;
+/** Row entry with the approved stagger: rows of a fresh mission wait a short lead; later rows follow 60 ms apart. */
+export declare function rowEntryStart(state: Pick<MotionState, "entering" | "chipEnter">, key: string): number | undefined;
+/**
+ * Starts the tracks a state change calls for. A bar or warning already moving continues from where
+ * it is, so a burst of updates never makes either jump backwards.
+ */
+export declare function planMotion(prev: MissionView | undefined, next: MissionView, now: number, state: MotionState, enabled?: boolean): MotionState;
+export declare function sampleMotion(state: MotionState, now: number): MotionFrame;
+export declare function restingFrameFor(view: MissionView): MotionFrame;

package/dist/tui/mission-motion.js

@@ -0,0 +1,147 @@
+// Motion for the mission chip and panel. Everything here is a pure function of a clock value, so the
+// TUI only runs a frame timer while one of these tracks is still moving and stays static otherwise.
+import { missionRowKeys } from "./mission-model.js";
+export const motionTiming = Object.freeze({
+    stagger: 60,
+    entry: 160,
+    entryLead: 40,
+    fill: 300,
+    fillDelayOnGoal: 240,
+    noticeIn: 220,
+    crossfade: 140,
+    workDoneAt: 200,
+    reviewDoneAt: 260,
+    popAt: 300,
+    pop: 160,
+    shimmerAt: 300,
+    shimmer: 400,
+    settleAt: 1000,
+    complete: 1200,
+    frameMs: 33
+});
+export function clamp01(value) {
+    return value <= 0 ? 0 : value >= 1 ? 1 : value;
+}
+export const ease = Object.freeze({
+    outCubic: (x) => 1 - Math.pow(1 - x, 3),
+    inCubic: (x) => x * x * x,
+    inOutCubic: (x) => (x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2),
+    // Overshoots a little past 1 and settles back: the snap of a pill or row popping in.
+    outBack: (x) => {
+        const c1 = 1.70158;
+        const c3 = c1 + 1;
+        return 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2);
+    }
+});
+/** 0..1 progress of a track that starts `start` ms after the change and lasts `duration` ms. */
+export function seg(t, start, duration) {
+    if (duration <= 0)
+        return t >= start ? 1 : 0;
+    return clamp01((t - start) / duration);
+}
+/** Cells a row is pushed right while it slides in; the ease-out-back overshoot lands it a cell left first. */
+export function slideIn(progress, amplitude = 6) {
+    return Math.round(amplitude * (1 - ease.outBack(progress)));
+}
+function hexChannels(hex) {
+    const clean = hex.replace(/^#/u, "");
+    const full = clean.length === 3 ? clean.split("").map((c) => c + c).join("") : clean.slice(0, 6);
+    const value = Number.parseInt(full, 16);
+    if (!Number.isFinite(value) || full.length !== 6)
+        return [0, 0, 0];
+    return [(value >> 16) & 255, (value >> 8) & 255, value & 255];
+}
+export function mixHex(from, to, t) {
+    const a = hexChannels(from);
+    const b = hexChannels(to);
+    const k = clamp01(t);
+    return "#" + a.map((channel, index) => Math.round(channel + (b[index] - channel) * k).toString(16).padStart(2, "0")).join("");
+}
+export const idleMotion = Object.freeze({
+    entering: Object.freeze([]),
+    chipEnter: false,
+    barFrom: 0,
+    barTo: 0,
+    barDelay: 0,
+    warnFrom: 0,
+    warnTo: 0,
+    celebrate: false
+});
+function ratio(view) {
+    const progress = view?.progress;
+    if (progress === undefined || progress.total === 0)
+        return 0;
+    return clamp01(progress.done / progress.total);
+}
+function warnTarget(view) {
+    return view !== undefined && view.warnings.length > 0 ? 1 : 0;
+}
+/** Row entry with the approved stagger: rows of a fresh mission wait a short lead; later rows follow 60 ms apart. */
+export function rowEntryStart(state, key) {
+    const index = state.entering.indexOf(key);
+    if (index < 0)
+        return undefined;
+    return (state.chipEnter ? motionTiming.entryLead : 0) + index * motionTiming.stagger;
+}
+function rowDuration(key) {
+    return key.startsWith("warn:") ? motionTiming.noticeIn : motionTiming.entry;
+}
+function settleTime(state) {
+    let end = motionTiming.crossfade;
+    for (const key of state.entering)
+        end = Math.max(end, (rowEntryStart(state, key) ?? 0) + rowDuration(key));
+    if (state.chipEnter)
+        end = Math.max(end, 3 * motionTiming.stagger + motionTiming.entry);
+    if (state.barFrom !== state.barTo)
+        end = Math.max(end, state.barDelay + motionTiming.fill);
+    if (state.celebrate)
+        end = Math.max(end, motionTiming.complete);
+    return end;
+}
+/**
+ * Starts the tracks a state change calls for. A bar or warning already moving continues from where
+ * it is, so a burst of updates never makes either jump backwards.
+ */
+export function planMotion(prev, next, now, state, enabled = true) {
+    const nextRatio = ratio(next);
+    const nextWarn = warnTarget(next);
+    if (!enabled || !next.active)
+        return { ...idleMotion, barFrom: nextRatio, barTo: nextRatio, warnFrom: nextWarn, warnTo: nextWarn };
+    const current = sampleMotion(state, now);
+    const appearing = prev === undefined || !prev.active;
+    const before = new Set(appearing ? [] : missionRowKeys(prev));
+    const entering = missionRowKeys(next).filter((key) => !before.has(key));
+    const goalArrived = !appearing && prev?.goal === undefined && next.goal !== undefined;
+    return {
+        changeAt: now,
+        entering,
+        chipEnter: appearing,
+        barFrom: appearing ? 0 : current.barRatio,
+        barTo: nextRatio,
+        barDelay: goalArrived || appearing ? motionTiming.fillDelayOnGoal : 0,
+        warnFrom: appearing ? nextWarn : current.warn,
+        warnTo: nextWarn,
+        celebrate: !appearing && prev?.complete !== true && next.complete
+    };
+}
+export function sampleMotion(state, now) {
+    if (state.changeAt === undefined) {
+        return { t: Number.POSITIVE_INFINITY, entering: [], chipEnter: false, barRatio: state.barTo, warn: state.warnTo, moving: false };
+    }
+    const t = now - state.changeAt;
+    const moving = t < settleTime(state);
+    const fill = ease.inOutCubic(seg(t, state.barDelay, motionTiming.fill));
+    const fade = ease.inOutCubic(seg(t, 0, motionTiming.crossfade));
+    return {
+        t: moving ? t : Number.POSITIVE_INFINITY,
+        entering: moving ? state.entering : [],
+        chipEnter: moving && state.chipEnter,
+        barRatio: clamp01(state.barFrom + (state.barTo - state.barFrom) * fill),
+        warn: clamp01(state.warnFrom + (state.warnTo - state.warnFrom) * fade),
+        ...(moving && state.celebrate ? { celebrate: t } : {}),
+        moving
+    };
+}
+export function restingFrameFor(view) {
+    return { t: Number.POSITIVE_INFINITY, entering: [], chipEnter: false, barRatio: ratio(view), warn: warnTarget(view), moving: false };
+}

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

@@ -0,0 +1,56 @@
+import { type MissionInput, type TodoInput } from "./mission-model.ts";
+type MessageLike = {
+    readonly id: string;
+    readonly role: string;
+    readonly agent?: unknown;
+    readonly time?: {
+        readonly created?: unknown;
+    };
+    readonly providerID?: unknown;
+    readonly modelID?: unknown;
+    readonly tokens?: {
+        readonly input?: unknown;
+        readonly output?: unknown;
+        readonly reasoning?: unknown;
+        readonly cache?: {
+            readonly read?: unknown;
+            readonly write?: unknown;
+        };
+    };
+};
+export type MissionStateSource = {
+    readonly path: {
+        readonly worktree?: string;
+        readonly directory?: string;
+    };
+    readonly provider: ReadonlyArray<{
+        readonly id: string;
+        readonly models: Readonly<Record<string, {
+            readonly limit?: {
+                readonly context?: number;
+            };
+        }>>;
+    }>;
+    readonly session: {
+        messages(sessionID: string): ReadonlyArray<MessageLike>;
+        todo(sessionID: string): ReadonlyArray<TodoInput>;
+        status(sessionID: string): {
+            readonly type: string;
+            readonly message?: string;
+        } | undefined;
+        permission(sessionID: string): ReadonlyArray<unknown>;
+        question(sessionID: string): ReadonlyArray<unknown>;
+    };
+    part(messageID: string): ReadonlyArray<{
+        readonly metadata?: unknown;
+    }>;
+};
+/** The same root the server plugin uses: the worktree unless it is the filesystem root, else the directory. */
+export declare function missionProjectRoot(paths: MissionStateSource["path"]): string | undefined;
+/**
+ * Reads goals.json under `root`, refusing symbolic links and oversized files. The result is cached
+ * on mtime and size, so calling it on every refresh costs one lstat.
+ */
+export declare function createLedgerReader(): (root: string | undefined) => unknown;
+export declare function readMissionInput(state: MissionStateSource, sessionID: string, ledger: unknown, now: number): MissionInput;
+export {};

package/dist/tui/mission-source.js

@@ -0,0 +1,88 @@
+// Gathers the mission input from the OpenCode TUI state and the project's evidence ledger. The state
+// shape is the slice of `api.state` the plugin reads, so tests can pass a plain object.
+import fs from "node:fs";
+import path from "node:path";
+import { readLitMark } from "./mission-model.js";
+const ledgerByteLimit = 1024 * 1024;
+/** The same root the server plugin uses: the worktree unless it is the filesystem root, else the directory. */
+export function missionProjectRoot(paths) {
+    const worktree = paths.worktree?.trim();
+    if (worktree !== undefined && worktree !== "" && worktree !== "/")
+        return worktree;
+    const directory = paths.directory?.trim();
+    return directory === undefined || directory === "" ? undefined : directory;
+}
+/**
+ * Reads goals.json under `root`, refusing symbolic links and oversized files. The result is cached
+ * on mtime and size, so calling it on every refresh costs one lstat.
+ */
+export function createLedgerReader() {
+    let cache;
+    return (root) => {
+        if (root === undefined)
+            return undefined;
+        const file = path.join(root, ".litopencode", "litgoal", "lit-loop", "goals.json");
+        let stat;
+        try {
+            stat = fs.lstatSync(file);
+        }
+        catch {
+            return undefined;
+        }
+        if (!stat.isFile() || stat.size > ledgerByteLimit)
+            return undefined;
+        const stamp = `${stat.mtimeMs}:${stat.size}`;
+        if (cache?.file === file && cache.stamp === stamp)
+            return cache.value;
+        let value;
+        try {
+            value = JSON.parse(fs.readFileSync(file, "utf8"));
+        }
+        catch {
+            value = undefined;
+        }
+        cache = { file, stamp, value };
+        return value;
+    };
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function contextPercent(state, messages) {
+    const last = [...messages].reverse().find((message) => message.role === "assistant" && num(message.tokens?.output) > 0);
+    if (last === undefined)
+        return null;
+    const tokens = num(last.tokens?.input) + num(last.tokens?.output) + num(last.tokens?.reasoning) + num(last.tokens?.cache?.read) + num(last.tokens?.cache?.write);
+    const limit = state.provider.find((provider) => provider.id === last.providerID)?.models[String(last.modelID)]?.limit?.context;
+    return typeof limit === "number" && limit > 0 ? (tokens / limit) * 100 : null;
+}
+export function readMissionInput(state, sessionID, ledger, now) {
+    const messages = state.session.messages(sessionID);
+    const marks = [];
+    let agent;
+    for (const message of messages) {
+        if (message.role !== "user")
+            continue;
+        if (typeof message.agent === "string")
+            agent = message.agent;
+        const at = num(message.time?.created);
+        for (const part of state.part(message.id)) {
+            const mark = readLitMark(part.metadata, at);
+            if (mark !== undefined)
+                marks.push(mark);
+        }
+    }
+    const status = state.session.status(sessionID);
+    return {
+        marks,
+        ...(agent === undefined ? {} : { agent }),
+        todos: state.session.todo(sessionID),
+        ledger,
+        ...(status === undefined ? {} : { sessionStatus: status.type }),
+        ...(status?.type === "retry" && typeof status.message === "string" ? { retryMessage: status.message } : {}),
+        pendingPermissions: state.session.permission(sessionID).length,
+        pendingQuestions: state.session.question(sessionID).length,
+        contextPercent: contextPercent(state, messages),
+        now
+    };
+}