@litfamily/litopencode 1.0.20 → 1.0.22

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,10 +229,17 @@ 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
     };
 }
-/** What the band card shows beside the mission: the session's skill chips, context use and git branch. */
+/**
+ * What the band card shows beside the mission: the session's skill chips, whether a turn is running,
+ * context use and git branch. OpenCode keeps each session's last `session.status` ({ type: "busy" },
+ * "retry" or "idle"); a session it has not seen run has none, which counts as not running.
+ */
 export function readCardInput(state, sessionID) {
     const messages = state.session.messages(sessionID);
     const uses = [];
@@ -103,9 +255,11 @@ export function readCardInput(state, sessionID) {
         }
     }
     const status = state.session.status(sessionID)?.type;
+    const busy = status === "busy" || status === "retry";
     const branch = state.vcs?.branch?.trim();
     return {
-        chips: skillChips(uses, { since, busy: status === "busy" || status === "retry" }),
+        chips: skillChips(uses, { since, busy }),
+        busy,
         contextPercent: contextPercent(state, messages),
         ...(branch === undefined || branch === "" ? {} : { branch })
     };

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 = {