@litfamily/litopencode 1.0.21 → 1.0.23

package/dist/tui/mission-motion.js

@@ -1,6 +1,6 @@
 // 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";
+import { currentStepIndex, missionRowKeys } from "./mission-model.js";
 export const motionTiming = Object.freeze({
     stagger: 60,
     entry: 160,
@@ -96,6 +96,8 @@ function settleTime(state) {
         end = Math.max(end, state.barDelay + motionTiming.fill);
     if (state.celebrate)
         end = Math.max(end, motionTiming.complete);
+    if (state.stageFrom !== undefined)
+        end = Math.max(end, motionTiming.shimmer);
     return end;
 }
 /**
@@ -110,8 +112,12 @@ export function planMotion(prev, next, now, state, enabled = true) {
     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));
+    // The live step changes with every tool call, so its row appears in place instead of sliding in.
+    const entering = missionRowKeys(next).filter((key) => !before.has(key) && key !== "live");
     const goalArrived = !appearing && prev?.goal === undefined && next.goal !== undefined;
+    const from = appearing || prev === undefined ? -1 : currentStepIndex(prev);
+    const to = currentStepIndex(next);
+    const celebrate = !appearing && prev?.complete !== true && next.complete;
     return {
         changeAt: now,
         entering,
@@ -121,12 +127,14 @@ export function planMotion(prev, next, now, state, enabled = true) {
         barDelay: goalArrived || appearing ? motionTiming.fillDelayOnGoal : 0,
         warnFrom: appearing ? nextWarn : current.warn,
         warnTo: nextWarn,
-        celebrate: !appearing && prev?.complete !== true && next.complete
+        celebrate,
+        ...(from >= 0 && to > from && prev?.family === next.family ? { stageFrom: from } : {}),
+        ...(celebrate && from >= 0 ? { celebrateFrom: from } : {})
     };
 }
 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 };
+        return { t: Number.POSITIVE_INFINITY, entering: [], chipEnter: false, barRatio: state.barTo, warn: state.warnTo, now, moving: false };
     }
     const t = now - state.changeAt;
     const moving = t < settleTime(state);
@@ -138,10 +146,12 @@ export function sampleMotion(state, now) {
         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 && state.celebrate ? { celebrate: t, ...(state.celebrateFrom === undefined ? {} : { celebrateFrom: state.celebrateFrom }) } : {}),
+        ...(moving && state.stageFrom !== undefined ? { stageFrom: state.stageFrom } : {}),
+        now,
         moving
     };
 }
-export function restingFrameFor(view) {
-    return { t: Number.POSITIVE_INFINITY, entering: [], chipEnter: false, barRatio: ratio(view), warn: warnTarget(view), moving: false };
+export function restingFrameFor(view, now) {
+    return { t: Number.POSITIVE_INFINITY, entering: [], chipEnter: false, barRatio: ratio(view), warn: warnTarget(view), ...(now === undefined ? {} : { now }), moving: false };
 }

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

@@ -1,4 +1,4 @@
-import { type MissionInput, type TodoInput } from "./mission-model.ts";
+import { type LiveStep, type MissionInput, type ResearchInput, type TodoInput, type WorkInput } from "./mission-model.ts";
 import { type SkillChip } from "./mission-skills.ts";
 type MessageLike = {
     readonly id: string;
@@ -47,17 +47,42 @@ export type MissionStateSource = {
     };
     part(messageID: string): ReadonlyArray<{
         readonly type?: string;
+        readonly tool?: unknown;
+        readonly state?: unknown;
         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. */
+export declare function createLedgerReader(): (root: string | undefined) => unknown;
 /**
- * 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.
+ * Reads this session's bounded work from work-schema-3.json and the checklist of the plan it names.
+ * The plan must be a regular file inside `root`; anything else leaves the checklist out.
  */
-export declare function createLedgerReader(): (root: string | undefined) => unknown;
-export declare function readMissionInput(state: MissionStateSource, sessionID: string, ledger: unknown, now: number): MissionInput;
+export declare function createWorkReader(): (root: string | undefined, sessionID: string) => WorkInput | undefined;
+/**
+ * What a litresearch run folder says so far. The skill keeps a root-owned journal.md, an append-only
+ * claim-graph.jsonl and a final report.md; the stage is read from them: a report is synthesis, a
+ * claim with a gate result is verify, a journal whose last heading names EXPAND is expand, claims are
+ * a wave (numbered by the highest `wave` field or `## Wave` heading), and nothing yet is decompose.
+ */
+export declare function readResearchRun(journal: string, claimGraph: string, reported: boolean, touchedAt: number): ResearchInput;
+/**
+ * The most recently written run under .litopencode/litgoal/lit-loop/research/, or undefined when
+ * there is none. Symbolic links are skipped and only the three known files are read.
+ */
+export declare function readLatestResearchRun(root: string | undefined): ResearchInput | undefined;
+/**
+ * The tool the session's latest assistant message is running: its name and `time.start` from the
+ * running tool part. The input is never read.
+ */
+export declare function readLiveStep(state: MissionStateSource, messages: ReadonlyArray<MessageLike>): LiveStep | undefined;
+export type MissionRecords = {
+    readonly work?: WorkInput;
+    readonly research?: ResearchInput;
+};
+export declare function readMissionInput(state: MissionStateSource, sessionID: string, ledger: unknown, now: number, records?: MissionRecords): MissionInput;
 export type CardInput = {
     readonly chips: readonly SkillChip[];
     readonly busy: boolean;

package/dist/tui/mission-source.js

@@ -1,8 +1,9 @@
-// Gathers the mission input from the OpenCode TUI state and the project's evidence ledger. The state
+// Gathers the mission input from the OpenCode TUI state and the project's own records: the evidence
+// ledger, the bounded work record with its plan checklist, and litresearch run folders. 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";
+import { planChecklist, readLitMark, readWorkState } from "./mission-model.js";
 import { readSkillUse, skillChips } from "./mission-skills.js";
 const ledgerByteLimit = 1024 * 1024;
 /** The same root the server plugin uses: the worktree unless it is the filesystem root, else the directory. */
@@ -14,15 +15,12 @@ export function missionProjectRoot(paths) {
     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.
+ * A reader for one regular file that refuses symbolic links and files over 1 MiB, cached on mtime and
+ * size so a call on every refresh costs one lstat.
  */
-export function createLedgerReader() {
+function createFileReader(parse) {
     let cache;
-    return (root) => {
-        if (root === undefined)
-            return undefined;
-        const file = path.join(root, ".litopencode", "litgoal", "lit-loop", "goals.json");
+    return (file) => {
         let stat;
         try {
             stat = fs.lstatSync(file);
@@ -37,7 +35,7 @@ export function createLedgerReader() {
             return cache.value;
         let value;
         try {
-            value = JSON.parse(fs.readFileSync(file, "utf8"));
+            value = parse(fs.readFileSync(file, "utf8"));
         }
         catch {
             value = undefined;
@@ -46,6 +44,131 @@ export function createLedgerReader() {
         return value;
     };
 }
+function litLoopDir(root) {
+    return path.join(root, ".litopencode", "litgoal", "lit-loop");
+}
+/** Reads goals.json under `root`, refusing symbolic links and oversized files. */
+export function createLedgerReader() {
+    const read = createFileReader((text) => JSON.parse(text));
+    return (root) => (root === undefined ? undefined : read(path.join(litLoopDir(root), "goals.json")));
+}
+/**
+ * Reads this session's bounded work from work-schema-3.json and the checklist of the plan it names.
+ * The plan must be a regular file inside `root`; anything else leaves the checklist out.
+ */
+export function createWorkReader() {
+    const readState = createFileReader((text) => JSON.parse(text));
+    const readPlan = createFileReader(planChecklist);
+    return (root, sessionID) => {
+        if (root === undefined)
+            return undefined;
+        const work = readWorkState(readState(path.join(litLoopDir(root), "work-schema-3.json")), sessionID);
+        if (work === undefined)
+            return undefined;
+        const inside = work.planPath !== "" && path.isAbsolute(work.planPath) && !path.relative(path.resolve(root), work.planPath).startsWith("..");
+        const plan = inside ? readPlan(work.planPath) : undefined;
+        return { status: work.status, iterations: work.iterations, ...(plan === undefined ? {} : { plan }) };
+    };
+}
+function lstatOrUndefined(file) {
+    try {
+        return fs.lstatSync(file);
+    }
+    catch {
+        return undefined;
+    }
+}
+function readSmall(file, stat) {
+    if (stat === undefined || !stat.isFile() || stat.size > ledgerByteLimit)
+        return "";
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+const verifiedWords = new Set(["verified", "abstained", "unresolved", "refuted"]);
+/**
+ * What a litresearch run folder says so far. The skill keeps a root-owned journal.md, an append-only
+ * claim-graph.jsonl and a final report.md; the stage is read from them: a report is synthesis, a
+ * claim with a gate result is verify, a journal whose last heading names EXPAND is expand, claims are
+ * a wave (numbered by the highest `wave` field or `## Wave` heading), and nothing yet is decompose.
+ */
+export function readResearchRun(journal, claimGraph, reported, touchedAt) {
+    let claims = 0;
+    let verified = 0;
+    let gated = false;
+    let waveField = 0;
+    for (const line of claimGraph.split(/\r?\n/u)) {
+        if (line.trim() === "")
+            continue;
+        let row;
+        try {
+            row = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof row !== "object" || row === null)
+            continue;
+        claims += 1;
+        const record = row;
+        if (typeof record.wave === "number" && Number.isFinite(record.wave))
+            waveField = Math.max(waveField, Math.floor(record.wave));
+        const verdict = [record.gate, record.status, record.verdict].find((value) => typeof value === "string" && verifiedWords.has(value.toLowerCase()));
+        if (verdict !== undefined) {
+            gated = true;
+            if (String(verdict).toLowerCase() === "verified")
+                verified += 1;
+        }
+    }
+    const headings = journal.split(/\r?\n/u).filter((line) => /^#{1,6}\s/u.test(line)).map((line) => line.replace(/^#+\s*/u, "").toLowerCase());
+    const waveHeadings = headings.filter((heading) => /^wave\b/u.test(heading)).length;
+    const last = headings.at(-1) ?? "";
+    const waves = Math.max(waveField, waveHeadings, claims > 0 ? 1 : 0);
+    const stage = reported || /^synth/u.test(last)
+        ? "synthesis"
+        : gated || /^verif/u.test(last)
+            ? "verify"
+            : /^expand\b/u.test(last)
+                ? "expand"
+                : waves > 0 ? "wave" : "decompose";
+    return { stage, waves, claims, verified, reported, touchedAt };
+}
+/**
+ * The most recently written run under .litopencode/litgoal/lit-loop/research/, or undefined when
+ * there is none. Symbolic links are skipped and only the three known files are read.
+ */
+export function readLatestResearchRun(root) {
+    if (root === undefined)
+        return undefined;
+    const base = path.join(litLoopDir(root), "research");
+    const baseStat = lstatOrUndefined(base);
+    if (baseStat === undefined || !baseStat.isDirectory())
+        return undefined;
+    let latest;
+    let entries;
+    try {
+        entries = fs.readdirSync(base, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = path.join(base, entry.name);
+        const files = Object.fromEntries(["journal.md", "claim-graph.jsonl", "report.md"].map((name) => [name, lstatOrUndefined(path.join(dir, name))]));
+        const touchedAt = Math.max(lstatOrUndefined(dir)?.mtimeMs ?? 0, ...Object.values(files).map((stat) => stat?.mtimeMs ?? 0));
+        if (latest === undefined || touchedAt > latest.touchedAt)
+            latest = { dir, touchedAt, files };
+    }
+    if (latest === undefined)
+        return undefined;
+    const report = latest.files["report.md"];
+    return readResearchRun(readSmall(path.join(latest.dir, "journal.md"), latest.files["journal.md"]), readSmall(path.join(latest.dir, "claim-graph.jsonl"), latest.files["claim-graph.jsonl"]), report !== undefined && report.isFile() && report.size > 0, latest.touchedAt);
+}
 function num(value) {
     return typeof value === "number" && Number.isFinite(value) ? value : 0;
 }
@@ -57,7 +180,28 @@ function contextPercent(state, messages) {
     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) {
+/**
+ * The tool the session's latest assistant message is running: its name and `time.start` from the
+ * running tool part. The input is never read.
+ */
+export function readLiveStep(state, messages) {
+    const last = [...messages].reverse().find((message) => message.role === "assistant");
+    if (last === undefined)
+        return undefined;
+    let live;
+    for (const part of state.part(last.id)) {
+        if (part.type !== "tool" || typeof part.tool !== "string" || typeof part.state !== "object" || part.state === null)
+            continue;
+        const toolState = part.state;
+        const start = toolState.time?.start;
+        if (toolState.status !== "running" || typeof start !== "number" || !Number.isFinite(start))
+            continue;
+        if (live === undefined || start >= live.start)
+            live = { tool: part.tool, start };
+    }
+    return live;
+}
+export function readMissionInput(state, sessionID, ledger, now, records = {}) {
     const messages = state.session.messages(sessionID);
     const marks = [];
     let agent;
@@ -74,6 +218,7 @@ export function readMissionInput(state, sessionID, ledger, now) {
         }
     }
     const status = state.session.status(sessionID);
+    const live = readLiveStep(state, messages);
     return {
         marks,
         ...(agent === undefined ? {} : { agent }),
@@ -84,6 +229,9 @@ export function readMissionInput(state, sessionID, ledger, now) {
         pendingPermissions: state.session.permission(sessionID).length,
         pendingQuestions: state.session.question(sessionID).length,
         contextPercent: contextPercent(state, messages),
+        ...(records.work === undefined ? {} : { work: records.work }),
+        ...(records.research === undefined ? {} : { research: records.research }),
+        ...(live === undefined ? {} : { live }),
         now
     };
 }

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

@@ -1,5 +1,5 @@
 import { type MotionFrame } from "./mission-motion.ts";
-import { type MissionStep, type MissionView } from "./mission-model.ts";
+import { type MissionView } from "./mission-model.ts";
 export type Segment = {
     readonly text: string;
     readonly fg: string;
@@ -9,6 +9,7 @@ export type Segment = {
 export type Line = readonly Segment[];
 export type MissionPalette = {
     readonly primary: string;
+    readonly secondary: string;
     readonly accent: string;
     readonly info: string;
     readonly warning: string;
@@ -61,19 +62,43 @@ export declare function shimmerAt(frame: MotionFrame): number;
  * primary-to-accent gradient. The empty track is a thin muted rule, never a dither.
  */
 export declare function progressBar(ratio: number, cells: number, palette: MissionPalette, sweep?: number): Segment[];
-export declare function stepPill(step: MissionStep, view: MissionView, frame: MotionFrame, palette: MissionPalette): Segment;
+/** The stage colour ramp: the theme's primary through secondary to accent, so every theme keeps its own feel. */
+export declare function stageColor(index: number, count: number, palette: MissionPalette): string;
+/** A light pass over the running stage: once when the map moves forward, and during the completion moment. */
+export declare function stageFlash(frame: MotionFrame): number;
+/**
+ * The colour of the connector into stage `index`. It carries the stage ramp once the stage before it is
+ * behind the map, and fills in turn, 60 ms apart, when the map has just moved forward.
+ */
+export declare function linkColor(view: MissionView, index: number, frame: MotionFrame, palette: MissionPalette, idle: string): string;
+/**
+ * One stage of the breadcrumb. Behind the map a stage is its name in its ramp colour with `✓` (or `–`
+ * when skipped); ahead it is a muted name; the running stage is a filled capital pill followed by an
+ * optional `bar`-cell bar and the count.
+ */
+export declare function crumb(view: MissionView, index: number, frame: MotionFrame, palette: MissionPalette, bar: number, flash?: number): Segment[];
+/**
+ * The live step: the running tool's name and how long it has run, `⠹ bash · 0:48`. The spinner moves
+ * with the elapsed second, so it changes only when the time does. Nothing of the tool's input is shown.
+ */
+export declare function liveSegments(view: MissionView, frame: MotionFrame, palette: MissionPalette, room: number): Segment[];
 export type ChipTier = "full" | "medium" | "tight";
 export type ChipGroup = readonly Segment[];
-/** The chip's pill groups for a tier; the five-segment bar is appended unless `withMicroBar` is false. */
-export declare function chipGroups(view: MissionView, frame: MotionFrame, palette: MissionPalette, tier: ChipTier, withMicroBar?: boolean): ChipGroup[];
+/**
+ * The chip's groups for a tier. The full tier is the brand and the breadcrumb around the running stage
+ * (the one before, the running one with a seven-cell bar, the one after); medium keeps the running
+ * stage and the next with a five-cell bar; tight keeps only the count.
+ */
+export declare function chipGroups(view: MissionView, frame: MotionFrame, palette: MissionPalette, tier: ChipTier): ChipGroup[];
 export declare function groupsWidth(groups: readonly ChipGroup[]): number;
 export declare function fade(segment: Segment, alpha: number, palette: MissionPalette): Segment;
 export declare const chipSparkWidth = 7;
 export declare function chipSparkCells(t: number, palette: MissionPalette): Segment[] | undefined;
 export declare function chipTier(view: MissionView, frame: MotionFrame, palette: MissionPalette, budget: number): ChipTier;
 /**
- * The phase chip on the right of the prompt's agent/model row: `🔥 LIT` `PLAN` › `WORK n/m` › `REVIEW`
- * and a five-segment bar, shedding labels before values as `budget` shrinks. Idle sessions render nothing.
+ * The map chip on the right of the prompt's agent/model row: `🔥 LIT  plan ✓ › WORK ▰▰▰▱▱▱▱ 3/7 › review`,
+ * then the live step when the full chip leaves room for it, shedding labels before values as `budget`
+ * shrinks. Idle sessions render nothing.
  */
 export declare function chipLine(view: MissionView, frame: MotionFrame, palette: MissionPalette, budget: number): Line;
 /** The header status: a glyph and words, or the COMPLETE badge that pops in and settles to green text. */
@@ -91,9 +116,9 @@ export type MissionPanel = {
 };
 /**
  * The sidebar mission panel: a rounded box whose border carries the state (accent while working,
- * warning on a warning, success when complete), a tiny LIT header, the goal title, the phase line,
- * the bar, the next item, criteria, warnings and the evidence timeline. Rows are at most
- * `panelInnerWidth` cells.
+ * warning on a warning, success when complete), a tiny LIT header, the goal title, the vertical stage
+ * map with its connectors, the bar, the detail line, the live step, criteria, warnings and the
+ * evidence timeline. Rows are at most `panelInnerWidth` cells.
  */
 export declare function missionPanel(view: MissionView, frame: MotionFrame, palette: MissionPalette): MissionPanel | undefined;
 export type LastMission = {