@litfamily/litopencode 1.0.32 → 1.0.33

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

@@ -30,10 +30,12 @@ export declare function readNotifyOptions(options: unknown): NotifyOptions;
  * dim recent names, and `+N` for the ones that do not fit. The label goes before any chip does.
  */
 export declare function skillRow(chips: readonly SkillChip[], shimmer: ChipShimmer | undefined, palette: MissionPalette, width: number, rainbow?: Rainbow): Line;
+/** `restartTo`: an installed LitOpenCode version newer than the code this OpenCode start loaded. */
 export type CardFigures = {
     readonly contextPercent: number | null;
     readonly branch?: string;
     readonly inLane: boolean;
+    readonly restartTo?: string;
 };
 export type CardInputs = {
     readonly view: MissionView;

package/dist/tui/mission-band.js

@@ -153,6 +153,8 @@ function topLine(view, frame, palette, width, border, rest, mark) {
 /** The figures in the bottom border, most important first; the last ones go first when room runs out. */
 function figureParts(view, figures, palette) {
     const parts = [];
+    if (figures.restartTo !== undefined)
+        parts.push({ text: `restart to ${truncateCells(figures.restartTo, 16)}`, fg: palette.warning });
     if (figures.contextPercent !== null) {
         const percent = Math.round(figures.contextPercent);
         parts.push({ text: `ctx ${percent}%`, fg: percent >= contextWarnPercent ? palette.warning : palette.muted });

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

@@ -123,8 +123,9 @@ export declare function readCardInput(state: MissionStateSource, sessionID: stri
 export declare const earlierWorkWindowMs: number;
 /**
  * The lanes beside this session's own mission: its workflow stack frames, its running `task` calls and
- * the stacks of other sessions in the workspace that moved in the last fifteen minutes. Only counts
- * that are real totals are carried; the input of a tool call is read for its description alone.
+ * the stacks of other sessions in the workspace that moved in the last fifteen minutes, read with their
+ * liveness records. Another session's completed start-work run shows as done. Only counts that are real
+ * totals are carried; the input of a tool call is read for its description alone.
  */
 export declare function readThreadSources(state: MissionStateSource, sessionID: string, root: string | undefined, now: number): ThreadSource[];
 /**

package/dist/tui/mission-source.js

@@ -8,6 +8,7 @@ import { isLaneResult, isReviewLane } from "./mission-looks.js";
 import { readSkillUse, skillChips } from "./mission-skills.js";
 import { isRealCount } from "./mission-threads.js";
 import { readSiblingStacksSync, readStackSync } from "../workflow-stack.js";
+import { readLivenessSync } from "../session-liveness.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) {
@@ -383,28 +384,60 @@ function stackSources(stack) {
         touchedAt: frame.at
     }));
 }
-function siblingSource(stack) {
+/** `<skill> · <herdr pane>` when the session runs in a herdr pane, else the last four characters of its id. */
+function siblingName(skill, sessionID, liveness) {
+    return `${skill} · ${liveness?.herdrPane ?? sessionID.slice(-4)}`;
+}
+/** A sibling's own liveness record settles its status: ended reads done, idle reads idle (a held frame stays paused). */
+function siblingSource(stack, liveness, finishedAt) {
     const top = stack.frames.find((frame) => frame.status === "active") ?? stack.frames[stack.frames.length - 1];
+    const endedAt = liveness?.state === "ended" ? Date.parse(liveness.at) : finishedAt;
+    const status = endedAt !== undefined ? "done" : top.status !== "active" ? "paused" : liveness?.state === "idle" ? "idle" : "working";
     return {
         kind: "session",
-        name: `${top.skill} · ${stack.sessionID.slice(-4)}`,
-        status: top.status === "active" ? "working" : "paused",
+        name: siblingName(top.skill, stack.sessionID, liveness),
+        status,
         ...countsOf(top.done, top.total),
         ...(top.phase === undefined ? {} : { phase: top.phase }),
-        touchedAt: stack.updatedAt
+        touchedAt: Math.max(stack.updatedAt, liveness === undefined ? 0 : Date.parse(liveness.at)),
+        ...(endedAt === undefined ? {} : { doneAt: endedAt }),
+        ...(liveness === undefined && finishedAt === undefined ? {} : { settled: true })
     };
 }
+/** Another session's start-work run that completed, with when, read from the bounded work record. */
+function finishedWork(root, sessionID, now) {
+    const file = path.join(litLoopDir(root), "work-schema-3.json");
+    const stat = lstatOrUndefined(file);
+    if (stat === undefined || !stat.isFile() || stat.size > ledgerByteLimit)
+        return undefined;
+    try {
+        const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!isRecord(raw) || raw.schemaVersion !== 3 || raw.status !== "completed" || typeof raw.sessionID !== "string" || raw.sessionID === sessionID)
+            return undefined;
+        const at = typeof raw.updatedAt === "string" ? Date.parse(raw.updatedAt) : Number.NaN;
+        return Number.isFinite(at) && at <= now && now - at <= siblingFreshMs ? { sessionID: raw.sessionID, at } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * The lanes beside this session's own mission: its workflow stack frames, its running `task` calls and
- * the stacks of other sessions in the workspace that moved in the last fifteen minutes. Only counts
- * that are real totals are carried; the input of a tool call is read for its description alone.
+ * the stacks of other sessions in the workspace that moved in the last fifteen minutes, read with their
+ * liveness records. Another session's completed start-work run shows as done. Only counts that are real
+ * totals are carried; the input of a tool call is read for its description alone.
  */
 export function readThreadSources(state, sessionID, root, now) {
     const tasks = taskSources(state, sessionID, now);
     if (root === undefined)
         return tasks.sources;
     const siblings = readSiblingStacksSync(root, sessionID, { now, freshMs: siblingFreshMs, max: siblingMax }).filter((stack) => !tasks.children.has(stack.sessionID));
-    return [...stackSources(readStackSync(root, sessionID)), ...tasks.sources, ...siblings.map(siblingSource)];
+    const finished = finishedWork(root, sessionID, now);
+    const others = siblings.map((stack) => siblingSource(stack, readLivenessSync(root, stack.sessionID), stack.sessionID === finished?.sessionID ? finished.at : undefined));
+    if (finished !== undefined && !siblings.some((stack) => stack.sessionID === finished.sessionID) && !tasks.children.has(finished.sessionID)) {
+        others.push({ kind: "session", name: siblingName("start-work", finished.sessionID, readLivenessSync(root, finished.sessionID)), status: "done", touchedAt: finished.at, doneAt: finished.at, settled: true });
+    }
+    return [...stackSources(readStackSync(root, sessionID)), ...tasks.sources, ...others];
 }
 /**
  * Whether earlier work exists for the band's idle hint and the one suggestion: another session here

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

@@ -13,6 +13,10 @@ export type ThreadSource = {
     readonly startedAt?: number;
     /** When the lane last moved; an old one reads as idle. */
     readonly touchedAt?: number;
+    /** When a done lane finished; it leaves the card a minute later. */
+    readonly doneAt?: number;
+    /** The status came from the session's liveness record, so the five-minute idle guess does not apply. */
+    readonly settled?: boolean;
 };
 export type ThreadRow = {
     readonly key: string;
@@ -25,10 +29,14 @@ export type ThreadRow = {
 export declare const threadRowCap = 4;
 /** A lane untouched for this long is shown as idle rather than working. */
 export declare const idleAfterMs: number;
+/** A finished lane stays this long, so a glance still catches it, then leaves. */
+export declare const doneLingerMs = 60000;
 export declare function isRealCount(done: unknown, total: unknown): done is number;
 /**
- * The rows for the sources, or undefined when fewer than two lanes exist: one lane is the session's own
- * work, which the four-row card already shows. A source untouched for five minutes reads as idle.
+ * The rows for the sources, or undefined when only one lane of the session's own work exists, which the
+ * four-row card already shows; one other session is still a row. A source untouched for five minutes reads
+ * as idle unless a liveness record settled it, a done lane leaves a minute after it finished, and other
+ * sessions follow the session's own lanes, working first, then paused, finished and idle.
  */
 export declare function threadsOf(sources: readonly ThreadSource[], now: number): ThreadRow[] | undefined;
 /** How many card rows the threads take: the fork line, the shown lanes and the `+N more` line. */

package/dist/tui/mission-threads.js

@@ -9,6 +9,9 @@ import { cellWidth, lineWidth, truncateCells } from "./mission-text.js";
 export const threadRowCap = 4;
 /** A lane untouched for this long is shown as idle rather than working. */
 export const idleAfterMs = 5 * 60_000;
+/** A finished lane stays this long, so a glance still catches it, then leaves. */
+export const doneLingerMs = 60_000;
+const sessionRank = { working: 0, paused: 1, done: 2, failed: 2, idle: 3 };
 const pulseFrames = ["▓▒░░░", "░▓▒░░", "░░▓▒░", "░░░▓▒", "░░▒▓░", "░▒▓░░"];
 const steadyPulse = "░▒▓▒░";
 const pulseMs = 250;
@@ -34,14 +37,20 @@ function factsFor(source, status, now) {
     return parts.join(" · ");
 }
 /**
- * The rows for the sources, or undefined when fewer than two lanes exist: one lane is the session's own
- * work, which the four-row card already shows. A source untouched for five minutes reads as idle.
+ * The rows for the sources, or undefined when only one lane of the session's own work exists, which the
+ * four-row card already shows; one other session is still a row. A source untouched for five minutes reads
+ * as idle unless a liveness record settled it, a done lane leaves a minute after it finished, and other
+ * sessions follow the session's own lanes, working first, then paused, finished and idle.
  */
 export function threadsOf(sources, now) {
-    if (sources.length < 2)
+    const live = sources.filter((source) => !(source.status === "done" && source.doneAt !== undefined && now - source.doneAt > doneLingerMs));
+    const statusOf = (source) => source.status === "working" && source.settled !== true && source.touchedAt !== undefined && now - source.touchedAt > idleAfterMs ? "idle" : source.status;
+    const own = live.filter((source) => source.kind !== "session");
+    const others = live.filter((source) => source.kind === "session").sort((left, right) => sessionRank[statusOf(left)] - sessionRank[statusOf(right)]);
+    if (others.length === 0 && own.length < 2)
         return undefined;
-    return sources.map((source, index) => {
-        const status = source.status === "working" && source.touchedAt !== undefined && now - source.touchedAt > idleAfterMs ? "idle" : source.status;
+    return [...own, ...others].map((source, index) => {
+        const status = statusOf(source);
         return {
             key: `${source.kind}:${index}:${source.name}`,
             name: source.name,
@@ -110,7 +119,7 @@ export function threadLines(rows, palette, width, options) {
         return [];
     const shown = rows.slice(0, threadRowCap);
     const more = rows.length - shown.length;
-    const fork = [{ text: "┬ ", fg: palette.borderSubtle }, { text: `${rows.length} lanes in parallel`, fg: palette.muted }];
+    const fork = [{ text: "┬ ", fg: palette.borderSubtle }, { text: `${rows.length} ${rows.length === 1 ? "lane" : "lanes"} in parallel`, fg: palette.muted }];
     const lines = [fork];
     shown.forEach((row, index) => lines.push(rowLine(row, index, index === shown.length - 1 && more === 0, palette, width, options)));
     if (more > 0)

package/dist/tui.js

@@ -10,12 +10,15 @@ import { bandCard, readBandOptions, readNotifyOptions, statusCard } from "./tui/
 import { activeSkillLook, turnGlow, waitingOnYou } from "./tui/mission-looks.js";
 import { rainbowActive, rainbowAllowed, rainbowAt, rainbowShows, rainbowTickMs } from "./tui/mission-rainbow.js";
 import { threadLineCount, threadsOf } from "./tui/mission-threads.js";
+import { readPackageMetadata } from "./cli/json.js";
+import { readInstalledVersions, restartVersion } from "./restart-notice.js";
 export const litOpenCodeTuiPluginId = "litopencode";
 const homeLineWidth = 69;
 const refreshDelayMs = 80;
 const ledgerPollMs = 2000;
 const toastMs = 4000;
 const liveTickMs = 1000;
+const restartCheckMs = 10 * 60_000;
 const trackedSessionLimit = 4;
 const refreshEvents = [
     "message.updated",
@@ -57,6 +60,21 @@ const tui = async (api, options) => {
     const suggested = new Set();
     const suggestedDays = new Map();
     const colorAllowed = rainbowAllowed(motionEnabled, process.env.NO_COLOR);
+    // The version this start loaded; an install newer than it shows `restart to <v>` and one toast.
+    const loaded = await readPackageMetadata().catch(() => undefined);
+    const [restartTo, setRestartTo] = createSignal(undefined);
+    let restartTimer;
+    async function checkRestart() {
+        if (loaded === undefined)
+            return;
+        const target = restartVersion(loaded.version, await readInstalledVersions(loaded.packageRoot).catch(() => []));
+        if (target === undefined || target === restartTo())
+            return;
+        if (restartTo() === undefined) {
+            api.ui.toast({ variant: "info", title: "🔥 LIT", message: `LitOpenCode ${target} is installed. Restart OpenCode to load it.`, duration: toastMs });
+        }
+        setRestartTo(target);
+    }
     const state = () => api.state;
     const palette = () => paletteFromTheme(api.theme.current, api.theme.mode());
     // OpenCode keeps the sidebar choice in its KV store under "sidebar" ("auto" or "hide"); a child
@@ -269,7 +287,11 @@ const tui = async (api, options) => {
     for (const type of refreshEvents) {
         api.event.on(type, scheduleRefresh);
     }
+    void checkRestart();
+    restartTimer = setInterval(() => void checkRestart(), restartCheckMs);
     api.lifecycle.onDispose(() => {
+        if (restartTimer !== undefined)
+            clearInterval(restartTimer);
         if (frameTimer !== undefined)
             clearInterval(frameTimer);
         if (refreshTimer !== undefined)
@@ -401,7 +423,12 @@ const tui = async (api, options) => {
                                     ...(rainbowOn(snapshot, snapshot.now) ? { rainbow: rainbowAt(snapshot.now) } : {}),
                                     ...(snapshot.card.lanes !== undefined && activeSkillLook(snapshot.view, snapshot.card.chips, snapshot.card.busy) === "review" ? { lanes: snapshot.card.lanes } : {}),
                                     ...(shimmer === undefined ? {} : { shimmer }),
-                                    figures: { contextPercent: snapshot.card.contextPercent, ...(snapshot.card.branch === undefined ? {} : { branch: snapshot.card.branch }), inLane: snapshot.inLane },
+                                    figures: {
+                                        contextPercent: snapshot.card.contextPercent,
+                                        ...(snapshot.card.branch === undefined ? {} : { branch: snapshot.card.branch }),
+                                        inLane: snapshot.inLane,
+                                        ...(restartTo() === undefined ? {} : { restartTo: restartTo() })
+                                    },
                                     ...(last === undefined ? {} : { last })
                                 }, colors, width);
                                 const rows = lines.map(lineElement);

package/dist/v2/events.js

@@ -1,5 +1,6 @@
 import { createAutoHandoff } from "../auto-handoff-hooks.js";
 import { LifecycleConflictError, LifecycleSafetyError, createBoundedAuthorityLifecycle, parseFencedProgress } from "../bounded-authority.js";
+import { markLiveness } from "../session-liveness.js";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -100,6 +101,7 @@ export function createV2Events(options) {
                     if (step.sessionID === sessionID)
                         steps.delete(messageID);
                 options.onSessionDeleted(sessionID);
+                await markLiveness(options.projectRoot, sessionID, "ended");
                 await toHandoff("session.deleted", { info: { id: sessionID } });
                 return;
             case "session.step.started": {
@@ -138,6 +140,7 @@ export function createV2Events(options) {
                 await toHandoff("session.status", { sessionID, status: data.status });
                 return;
             case "session.idle":
+                await markLiveness(options.projectRoot, sessionID, "idle");
                 await toHandoff("session.idle", { sessionID });
                 return;
             case "session.compaction.ended":

package/docs/assets/readme/badge-version.svg

@@ -1 +1 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.32"><title>release: 1.0.32</title><g shape-rendering="crispEdges"><rect width="49" height="20" fill="#080d14"/><rect x="49" width="97" height="20" fill="#ff6337"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text x="255" y="140" textLength="390" transform="scale(.1)">release</text><text x="965" y="140" textLength="870" transform="scale(.1)" fill="#080D14">1.0.32</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.33"><title>release: 1.0.33</title><g shape-rendering="crispEdges"><rect width="49" height="20" fill="#080d14"/><rect x="49" width="97" height="20" fill="#ff6337"/></g><g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" text-rendering="geometricPrecision" font-size="110"><text x="255" y="140" textLength="390" transform="scale(.1)">release</text><text x="965" y="140" textLength="870" transform="scale(.1)" fill="#080D14">1.0.33</text></g></svg>

package/docs/reference-Ko-KR.md

@@ -141,7 +141,7 @@ litopencode install
 | `/litgoal` | 끝나는 지점을 정하고 지킴: 확인 가능한 기준이 붙은 목표 하나를 디스크에 남김. `lit-loop`와 `/start-work`가 그 목표를 향해 일함 |
 | `/lit-brainstorm` | 열린 질문을 여러 선택지로 펼친 뒤 짧은 목록으로 좁히고, 고른 것을 `deep-interview`나 `lit-plan`에 넘김. 채팅에서는 `lit brainstorm`, `lit brainstorming`, `lit ideation`, `lit ideate`, `lit idea`, `lit ideas`. 직접 만들지는 않음 |
 | `/lit-hijack` | 다른 사람이 공개한 작업의 기법 원리를 내 스킬이나 시스템에 옮김: 출처 기록, 라이선스 확인, 격차 분석, 원문 없는 명세, 분리된 구현, 동작 비교, 보고서. 각 단계의 완료는 동봉된 `hijack.mjs`가 판정함. 채팅에서는 `lit hijack`, `lit hijacking`, `lit 하이재킹`, `lit 하이잭` |
-| `/lit-adhd`, `/lit-rewind` | 하던 일을 이어서 시작: 이전 세션의 상태, 실제 진행 또는 아는 사실, 로드맵, 추천 한 단계를 읽기 전용으로 보여 줌. 동봉된 `rewind.mjs`가 수집함. 채팅에서는 `lit adhd`, `lit rewind`, 이어서 `go`가 30분간 준비된 단계를 따라감. `lit approve`와 `lit deny`는 대기 중인 경계에 답하고, `lit deny`는 실행을 끝냄. |
+| `/lit-adhd`, `/lit-rewind` | 하던 일을 이어서 시작: 세 줄(지금까지, 지금, 다음)로 시작해 이전 세션의 상태, 실제 진행 또는 아는 사실, 로드맵, 추천 한 단계를 읽기 전용으로 보여 줌. 끝난 계획과 완료된 start-work 실행은 끝난 일로 세고, liveness 기록으로 쉬는 세션을 가리며, 7일 넘은 계획은 빼고, 이 워크트리 `HANDOFF.md`의 `Next` 항목을 마지막 대안으로 씀. 동봉된 `rewind.mjs`가 수집함. 채팅에서는 `lit adhd`, `lit rewind`, 이어서 `go`가 30분간 준비된 단계를 따라감. `lit approve`와 `lit deny`는 대기 중인 경계에 답하고, `lit deny`는 실행을 끝냄. |
 | `/litresearch` 또는 `/lit-research` | 순차 대체 경로를 포함한 근거 기반 연구 |
 | `/lit-handoff` | 이어서 작업할 수 있는 핸드오프 작성 |
 | `/lit-recap` | 로컬 ledger와 세션 맥락으로 짧은 리캡 작성 |
@@ -182,6 +182,15 @@ litopencode complete-goals
 bounded-authority 경로입니다. `resume`은 신뢰된 사용자 경로와 work, session, revision,
 grant가 모두 맞을 때만 허용됩니다. 복사하거나 인용한 텍스트는 명령으로 처리하지 않습니다.
 
+`/start-work save-plan <JSON>`으로 승인된 계획을 저장하면, 저장 안내와 함께 한 단어 시작이 준비됩니다.
+같은 세션에서 30분 안에 `go`를 입력하면 그 계획으로 타이핑 start-work 실행이 시작됩니다. 다른 세션의
+`go`나 30분이 지난 `go`는 평범한 단어입니다. 체크리스트가 프로젝트 밖의 절대 경로를 가리키는 계획에는
+`Scope roots: <폴더> (<동작>)` 줄이 있어야 합니다(동작은 `read`, `write`, `execute` 중에서). 이 줄로 덮이지
+않은 바깥 폴더가 있으면 save-plan은 저장하지 않고 넣을 줄을 그대로 알려 줍니다. 파일 시스템 루트, 최상위
+폴더, 홈 폴더 자체로만 덮을 수 있을 때는 더 좁은 기존 폴더를 적어 달라고 합니다. 코드 펜스 안의 경로와
+인라인 코드로 인용한 명령은 세지 않습니다. 타이핑 start-work가 시작되면 올바른 `Scope roots:` 줄 하나하나가
+실행의 권한이 되므로, 승인된 계획이 이미 적은 폴더 때문에 멈추지 않습니다. 이때 그 폴더는 있어야 합니다.
+
 ### UI 및 Visual QA 관리 헬퍼
 
 `frontend-ui-ux`와 `visual-qa` 경로는 Node ESM 헬퍼와 제한된 읽기 전용
@@ -413,7 +422,12 @@ OpenCode 1.18은 `tui.json`이나 `tui.jsonc`의 `plugin` 배열에 적힌 TUI
     상태 단어(`working`, `paused`, `done`, `failed`, `idle`), 그리고 실제 총량이 있을 때만 게이지
     (`[▉▉░░░░░░] 3/10`)가 붙습니다. 총량을 모르면 아는 것(단계, 걸린 시간)을 글로 쓰고 일하는 중이면 작은
     펄스를 보여 줄 뿐 물음표는 쓰지 않습니다. 작업이 살아 있는 동안 카드는 가장 높았던 높이를 유지하고,
-    모두 가라앉으면 네 줄로 돌아옵니다.
+    모두 가라앉으면 네 줄로 돌아옵니다. 다른 세션 줄은 이 세션의 작업 줄 뒤에 일하는 중, 멈춤, 끝남,
+    쉬는 중 순서로 놓이고, 다른 세션이 하나뿐이어도 줄이 생깁니다. 세션마다 훅이
+    `.litopencode/liveness/<session>.json`에 작은 기록을 남깁니다(도구 실행 뒤 `alive`, `session.idle`에서
+    `idle`, 세션 삭제 시 `ended`). 기록이 있으면 5분 추정 대신 그 기록으로 쉬는 중과 끝남을 정하고, herdr
+    pane에서 도는 세션은 `<skill> · <pane>`으로 부르며, 끝난 세션이나 다른 세션이 완료한 start-work 실행은
+    1분 동안 `done`으로 보였다가 사라집니다.
   - `lit-adhd`(별칭 `lit-rewind`)가 도는 동안 테두리, LIT 글자, 게이지가 같은 밝기의 색상환을 따라 돕니다.
     1초에 네 번 색이 조금씩 바뀌고 깜박이지 않습니다. `motion: false`와 `NO_COLOR`에서는 꺼집니다. 이전
     작업이 있는 작업 공간의 쉬는 세션은 `lit adhd to pick up where you left off`를 보여 주고, 그곳에서 처음 연
@@ -433,7 +447,10 @@ OpenCode 1.18은 `tui.json`이나 `tui.jsonc`의 `plugin` 배열에 적힌 TUI
   하위(subagent) 세션에서는 부모 세션의 카드를 `· in lane`과 함께 보여 주고, 홈 화면에는 띠가
   없습니다. 폭이 좁으면 줄마다 덜 중요한 것부터 덜어 냅니다. 단계 줄은 지금 하는 일과 다음 할 일
   글자, 막대 길이, 막대, 기준 개수를 차례로 빼고, 마지막에는 지금 단계만 남깁니다. 아래 테두리는 브랜치, 시간, context 사용량 순서로 뺍니다. 줄을
-  넘기지는 않습니다. 완료 순간도 여기서 함께 보입니다.
+  넘기지는 않습니다. 완료 순간도 여기서 함께 보입니다. 이번 OpenCode 시작 때 읽어 들인 코드보다 새
+  LitOpenCode가 설치되어 있으면(자동 업데이트 영수증이나 디스크의 패키지로 확인) 아래 테두리 맨 앞에
+  경고 색으로 `restart to <버전>`이 붙고, 폭이 좁아져도 가장 늦게 빠집니다. 같은 내용의 토스트도 한 번
+  뜹니다. 스스로 다시 시작하지는 않습니다.
 - 홈 화면 입력창 아래, OpenCode 팁 다음 줄: `🔥 lit ready · last: <목표> ✓ n/m`. 프로젝트 ledger에
   목표가 있을 때만 보입니다.
 - 경고는 색만 바꾸지 않고 늘 `⚑`와 글자를 함께 붙입니다. 색이 없어도 똑같이 읽히게 하려는

package/docs/reference.md

@@ -169,7 +169,7 @@ for an approved plan; `/review-work` checks the `DoneClaim` through a five-lane
 | `/litgoal` | Set and keep the finish line: one goal with checkable criteria on durable state. `lit-loop` and `/start-work` run toward it. |
 | `/lit-brainstorm` | Open a question into options, narrow them to a short list, and hand the pick to `deep-interview` or `lit-plan`. Chat: `lit brainstorm`, `lit brainstorming`, `lit ideation`, `lit ideate`, `lit idea`, `lit ideas`. It never builds. |
 | `/lit-hijack` | Port the mechanism in someone else's published work into your own skill or system: capture with provenance, licence gate, gap, source-free spec, separate build, parity proof and report. A bundled `hijack.mjs` decides when each phase is done. Chat: `lit hijack`, `lit hijacking`, `lit 하이재킹`, `lit 하이잭`. |
-| `/lit-adhd`, `/lit-rewind` | Pick up where you left off: a read-only brief of earlier sessions with status, real progress or known facts, a roadmap and one recommended step. A bundled `rewind.mjs` collects it. Chat: `lit adhd`, `lit rewind`; then `go` follows the armed step for 30 minutes. `lit approve` and `lit deny` answer a pending boundary; `lit deny` ends the run. |
+| `/lit-adhd`, `/lit-rewind` | Pick up where you left off: a read-only brief that opens with three lines (done so far, doing now, next), then earlier sessions with status, real progress or known facts, a roadmap and one recommended step. Finished plans and completed start-work runs count as done, a liveness record marks idle sessions, plans older than seven days stay out, and this worktree's `HANDOFF.md` `Next` item is the fallback step. A bundled `rewind.mjs` collects it. Chat: `lit adhd`, `lit rewind`; then `go` follows the armed step for 30 minutes. `lit approve` and `lit deny` answer a pending boundary; `lit deny` ends the run. |
 | `/litresearch` or `/lit-research` | Run evidence-backed research with a sequential fallback. |
 | `/lit-handoff` | Create a resumable handoff; exact bare `handoff` also routes here. |
 | `/lit-recap` | Read a concise recap from local ledger and session context. |
@@ -219,6 +219,16 @@ litopencode complete-goals
 surface for approved execution. Resume requires the trusted user route and matching work,
 session, revision, and grant; copied or quoted text is inert.
 
+When `/start-work save-plan <JSON>` saves an approved plan, the saved-plan notice arms a one-word start:
+typing `go` in that same session within 30 minutes starts the typed start-work run on that plan. A `go`
+from another session, or later, is an ordinary word. A plan whose checklist names an absolute path
+outside the project must carry a `Scope roots: <folder> (<actions>)` line (actions from `read`, `write`,
+`execute`); save-plan refuses an uncovered outside folder and replies with the exact line to add, or
+asks for a narrower existing folder when only the filesystem root, a top-level folder or the home
+folder would cover it. Paths in code fences and commands quoted in an inline code span do not count.
+When typed start-work begins, each valid `Scope roots:` line becomes a grant of the run, so it does
+not pause for a folder the approved plan named; the folder must exist then.
+
 Native goal verdict: the OpenCode host surface does not currently expose a native goal primitive;
 LitOpenCode uses `.litopencode/litgoal` instead. Static skills are installed under
 `skills/*/SKILL.md` and remain documentation unless a documented OpenCode route selects them.
@@ -535,7 +545,13 @@ What it draws:
     `paused`, `done`, `failed`, `idle`) and a gauge only when the lane has a real total
     (`[▉▉░░░░░░] 3/10`); otherwise it says what is known (the stage, how long it has run) and a
     working lane shows a small pulse, never a question mark. The card keeps its tallest height while
-    lanes are live and drops back to four rows once everything has settled;
+    lanes are live and drops back to four rows once everything has settled. Other sessions follow
+    this session's own lanes, working first, then paused, done and idle, and one other session is
+    already a row. Each session's hooks keep a small record in `.litopencode/liveness/<session>.json`
+    (`alive` after a tool, `idle` on `session.idle`, `ended` when the session is deleted); when a
+    record exists it decides idle and ended instead of the five-minute guess, a session running in
+    a herdr pane is named `<skill> · <pane>`, and an ended session or another session's completed
+    start-work run shows `done` for one minute and then leaves;
   - while `lit-adhd` (alias `lit-rewind`) runs, the border, the LIT word and the gauges cycle through
     the colour wheel at one fixed lightness, four small colour steps a second with no flashing. It
     is off under `motion: false` and `NO_COLOR`. An idle session in a workspace with earlier work
@@ -557,7 +573,10 @@ What it draws:
   A subagent session shows its parent's card with `· in lane`; the home screen has no band. When the
   card is narrow each row drops its own low-priority parts: the track drops the live step and
   next-task text, bar width, the bar, the criteria count and then every stage but the running one; the bottom border drops the branch,
-  then the time, then the context use. It never wraps. The completion moment plays here too.
+  then the time, then the context use. It never wraps. When an installed LitOpenCode is newer than the
+  code this OpenCode start loaded (the automatic update's receipt or the package on disk says so), the
+  bottom border starts with `restart to <version>` in the warning colour, the last figure to go, and one
+  toast says the same; nothing restarts on its own. The completion moment plays here too.
 - A line under the home prompt, after OpenCode's tips: `🔥 lit ready · last: <goal> ✓ n/m`. It
   appears only when the project ledger holds a goal.
 - Warnings always carry `⚑` and words, not colour alone, so they read the same without colour.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litfamily/litopencode",
-  "version": "1.0.32",
+  "version": "1.0.33",
   "description": "Workflow plugin for OpenCode: add lit to a prompt and the work is planned, built, checked and written down so the next session can pick it up.",
   "keywords": [
     "opencode",

package/skills/lit-adhd/SKILL.md

@@ -57,7 +57,7 @@ Use the OpenCode vocabulary for this contract: `chat.message`, `command.execute.
 | `session_id` | The id of the session that typed the request. The route prompt states it; pass it as `--session`. Without it the brief still prints but no `go` step is armed. |
 | `scope` | This worktree and the other worktrees of the same git repository. `--root <dir>` points elsewhere; `--all-dirs` is not used unless the user asks. |
 | `store` | The OpenCode session database (`opencode.db`), opened read-only, else the older JSON session store, else nothing. A missing store is said in words. |
-| `local_state` | `plans/*.md` and `.litopencode/plans/*.md` checklists, the active goal, the bounded start-work run, `.litopencode/workflow-stack/<session>.json`, `HANDOFF*.md` headings and `git log`. |
+| `local_state` | `plans/*.md` and `.litopencode/plans/*.md` checklists, the active goal, the bounded start-work run, `.litopencode/workflow-stack/<session>.json`, `.litopencode/liveness/<session>.json`, `HANDOFF*.md` headings and the first item under their `Next` heading, and `git log`. These small records are read before the session store, so a large store cannot use up the read budget first. |
 
 ## #contract.mode_matrix
 
@@ -77,7 +77,7 @@ Use the OpenCode vocabulary for this contract: `chat.message`, `command.execute.
 
 ## #contract.outputs
 
-- The brief, in Markdown: a headline, a card per live session grouped by worktree and branch, ended sessions as one table, the roadmap, one boxed recommended step, and `go`.
+- The brief, in Markdown: a three-line opener (done so far, doing now, next), a headline, a card per live session grouped by worktree and branch, ended sessions as one table, the roadmap, one boxed recommended step, and `go`.
 - At most one file written: `.litopencode/adhd/next-<session>.json`, only with `--write-next`, only for the asking session.
 - `PASS` when the brief printed, `BLOCKED:` with the missing capability otherwise.
 
@@ -151,12 +151,13 @@ The installed copy of the script sits next to this file; use its path from the s
 
 Shape (see `references/brief-format.md` for every rule and `references/card-examples.md` for worked cards):
 
+- Three opening lines from records only. `Done so far`: this worktree's newest commits in the seven-day window (two at most), its completed start-work run and its plans with every row ticked (three items in all), else its met goal. `Doing now`: this session while it works, else the running start-work run and its plan, else the newest working session. `Next`: the recommended step, with `(type go)` when `go` runs it here.
 - A headline: how many sessions, how many wait on the user, how many are active, and the one next step.
 - Live sessions (working, waiting, blocked, paused) as full cards under a heading per worktree and branch: a coloured badge, the goal in bold, a real gauge or the known facts in words, what is done (or, before any edit, the tools it used most), what is next (or what it is doing now).
 - Ended sessions folded into one table, one row each, at most eight: id, where, goal, how long ago, done.
-- The roadmap: recent commits with their dates (`✓`), the step in hand (`▶`), the steps after it (`○`). Unfilled plan scaffolds and another worktree's plans untouched for seven days are left out.
-- One boxed recommended step.
-- The closing line: `Type go to do it.` when a step is armed here, otherwise where to act.
+- The roadmap: recent commits with their dates (`✓`), the step in hand (`▶`), the steps after it (`○`). Unfilled plan scaffolds and any plan untouched for seven days, in this worktree or another, are left out. A plan with every row ticked is finished work: it counts in the opener, never in the roadmap.
+- One boxed recommended step, in an untagged fence so the chat draws the box as plain text.
+- The closing line: `Type go to do it.` when a step is armed here, otherwise where to act. When the read budget ran out before every plan was read, one more line says how many plans were not read.
 
 ### Progress is a bar or words, never filler
 
@@ -164,11 +165,11 @@ The collector draws `[▉▉▉░░░░░░░] 3/10` only when both numbe
 
 ### Status words
 
-`working`, `waits-on-you`, `blocked`, `paused`, `done`, `idle`. `references/status-taxonomy.md` lists the record behind each and the precedence when two apply.
+`working`, `waits-on-you`, `blocked`, `paused`, `done`, `idle`. A session that completed the start-work run, and has not moved since, reads `done`, and a done card names no next step. A session whose liveness record says idle or ended, at least as new as its last stored move, reads `idle` even inside the two-minute working window. The session asking for the brief is working. `references/status-taxonomy.md` lists the record behind each and the precedence when two apply.
 
 ### The recommended step
 
-One step, chosen in this order: something waiting on the user, a blocked session, a paused discipline, another running session (with what it is doing now), the running start-work run, the single open plan, the newest unfinished session, an open plan in another worktree, the most recent session that stopped. The box always names a real step from the records; only an empty window asks what to start. If the step belongs to this session and is one of continue, keep working, or start the plan, the collector writes the next-step record and `go` follows it. If it belongs to another session or worktree, the box says where to act and `go` here only repeats that pointer; it never starts the step.
+One step, chosen in this order: something waiting on the user, a blocked session, a paused discipline, another running session (with what it is doing now), the running start-work run, the single open plan, the first item under this worktree's `HANDOFF.md` `Next` heading (it never runs on `go`), the newest unfinished session, an open plan in another worktree, the most recent session that stopped. The box always names a real step from the records; only an empty window asks what to start. If the step belongs to this session and is one of continue, keep working, or start the plan, the collector writes the next-step record and `go` follows it. If it belongs to another session or worktree, the box says where to act and `go` here only repeats that pointer; it never starts the step.
 
 ## Following `go`
 

package/skills/lit-adhd/references/brief-format.md

@@ -6,6 +6,7 @@ The collector's `--brief` output is the only format; paste it as printed. This f
 
 The brief is Markdown, so OpenCode's chat draws it with the theme's colours.
 
+0. The opener, three lines kept apart by a hard break and followed by a blank line: `**Done so far:**` this worktree's newest commits in the seven-day window (two at most), then `` `plans/<name>.md` (start-work complete) `` for a completed run and `` `plans/<name>.md` `<gauge>` `` for a plan with every row ticked, three items in all, else its met goal, else `nothing finished in this window`; `**Doing now:**` the asking session's goal while it works, else `start-work · <plan>` for a running run, else the newest working session's goal, else `nothing running`; `**Next:**` the recommended step, ending in ``(type `go`)`` when a step is armed here.
 1. Headline: `## 🧭 <n> sessions · <k> waiting on you · <a> active · next: <short step>`, then one italic line naming the worktree family and how many worktrees had records (and a note when the store could not be read: missing database, old Node). Zero sessions print `No earlier sessions found here.` under the headings.
 2. Live sessions (working, waits-on-you, blocked, paused) as full cards, grouped under one `### 🌿 \`branch\` · worktree` heading per worktree, `(this one)` on the worktree the command ran in. Each card is one quote, its lines kept apart by a hard break:
    - a badge (🟢 ACTIVE, 🟠 WAITS ON YOU, 🔴 BLOCKED, ⏸️ PAUSED), the short id, how long ago it last moved, `this session` for the asking one, and the start-work boundary it waits on;
@@ -15,13 +16,15 @@ The brief is Markdown, so OpenCode's chat draws it with the theme's colours.
    - `▶ Next:` the first open todo, else the open plan step, else the open goal criterion, else what a running session is doing now (`now: Run the gates`), else `nothing pending on record`.
 3. Ended sessions (done, idle) under `### ⚪ Ended · <n>` as one table, newest first, at most eight rows and an italic count of the rest. Columns: id, where (cut to 20 cells), goal (cut to 44 cells), ago (the largest unit only: `5d`, `14h`, `20m`), done (`finished`, a file count, or `·`).
 4. `### 🗺️ Roadmap`: per worktree with something to show, up to three recent commits with their month-day (`✓`), the plan step in hand (`▶ **now**`), up to two steps after it (`○ **later**`); another worktree's lines carry its name in inline code.
-5. The box, `Recommended next step`, in a `text` code block so its frame keeps its columns: the step wrapped at word breaks to at most three lines, then `type: go` when a step is armed.
+5. The box, `Recommended next step`, in a code block with no language tag, so its frame keeps its columns and the chat draws it as plain text: the step wrapped at word breaks to at most three lines, then `type: go` when a step is armed.
 6. The closing line: ``Type **`go`** to do it.`` when a step is armed; otherwise `Nothing runs on its own here: open that session, or say what to do.`
+7. When the read budget ran out before every plan was read, an italic line: `<n> plans were not read (read budget used up).` Plans and the other small records are read before the session store, so this happens only with very large plan folders.
 
 ## Plans the roadmap leaves out
 
 - An unfilled scaffold: a row still holding a `<placeholder>`, or every row the same.
-- Another worktree's plan that has not changed in seven days. This worktree's plans always show.
+- Any plan that has not changed in seven days, in this worktree or another.
+- A plan with every row ticked: it is finished work and appears in the opener instead.
 
 ## Width and glyphs
 

package/skills/lit-adhd/references/card-examples.md

@@ -4,6 +4,10 @@ A complete brief as the collector prints it, from a fixture store with invented
 Markdown: the headings, bold status words, emoji badges, inline code and the table come out in the theme's colours.
 
 ````markdown
+**Done so far:** feat(billing): add the ledger tables; `plans/ledger.md` (start-work complete)  
+**Doing now:** Port the exporter  
+**Next:** In "Migrate the billing tables", answer the open question.
+
 ## 🧭 4 sessions · 1 waiting on you · 1 active · next: In "Migrate the billing tables", answer the open question.
 *this worktree family · 1 worktree with records*
 
@@ -35,7 +39,7 @@ Markdown: the headings, bold status words, emoji badges, inline code and the tab
 - ○ **later** · 4. totals check
 - ○ **later** · 5. cut-over
 
-```text
+```
 ╭─ Recommended next step ──────────────────────────────────────────────╮
 │ In "Migrate the billing tables", answer the open question.           │
 ╰──────────────────────────────────────────────────────────────────────╯
@@ -46,6 +50,8 @@ Nothing runs on its own here: open that session, or say what to do.
 
 What each part shows:
 
+- The opener reads only records: the newest commit, the start-work run that completed its plan, this session's
+  goal while it works, and the same step the box recommends.
 - The active card has a real total (the single open plan), so it has a bar. It has no edit yet, so `Done` names
   the tools it used most, never a count of calls.
 - The waiting card comes from a `question` tool call still open, and the box recommends answering it.
@@ -74,7 +80,22 @@ and says what it is doing now.
 Nothing runs on its own here: open that session, or say what to do.
 ```
 
-The box still names a real step from the records. Only an empty window says "say what to start".
+The box still names a real step from the records. When this worktree's `HANDOFF.md` has a `Next` heading, its
+first item comes first (`From HANDOFF.md: Wire the exporter to the CLI`). Only an empty window says "say what to
+start".
+
+## A finished run and an idle session
+
+```markdown
+| id | where | goal | ago | done |
+|---|---|---|---|---|
+| `run0a1b2` | billing-api | Run the ledger plan | 10m | finished |
+| `quiet9c8` | billing-api | Answer a question about the card | 1m | · |
+```
+
+The session that completed the start-work run reads done and names no next step, even though its to-do list
+still held an item. The second one moved a minute ago, but its liveness record says idle, so it is listed as
+ended rather than drawn as an active card.
 
 ## `--ascii`
 

package/skills/lit-adhd/references/status-taxonomy.md

@@ -7,10 +7,15 @@ Every card carries one status word. The collector picks the first that applies,
 | `waits-on-you` | `◆ WAITS ON YOU` | A `question` tool part still running or pending in the session, or the bounded run is `paused` with a pending boundary owned by the session. |
 | `blocked` | `✕ BLOCKED` | The newest tool part ended in `error` and nothing has run for more than two minutes. |
 | `paused` | `Ⅱ PAUSED` | The session's workflow stack holds a long discipline in the `paused` state. |
+| `working` | `● WORKING` | The session is the one asking for the brief. |
+| `done` | `✓ DONE` | The bounded start-work run is `completed`, owned by the session, and the session has not moved more than five seconds past the run's last update. |
+| `idle` | `○ IDLE` | The session's `.litopencode/liveness` record says `idle` or `ended` and is at most five seconds older than the session's last stored move. |
 | `working` | `● WORKING` | The session was updated within two minutes. |
 | `done` | `✓ DONE` | A real count whose done equals its total. |
 | `idle` | `○ IDLE` | None of the above. |
 
+A `done` card never names a next step: what it left open is history. An `alive` liveness record changes nothing; the two-minute window still decides.
+
 ## Count sources, in order
 
 1. The recorded stage count of a paused or active discipline in the stack (`lit-loop stage`).
@@ -26,4 +31,4 @@ Every card carries one status word. The collector picks the first that applies,
 
 ## Recommended-step precedence
 
-Waiting, blocked, paused, another session still working, the running start-work run (this session only), the single open plan, the newest idle session with a known next step. The next-step record is written only for `continue`, `work` and `plan`, and only when the step belongs to the asking session.
+Waiting, blocked, paused, another session still working, the running start-work run (this session only), the single open plan, this worktree's `HANDOFF.md` `Next` item, the newest idle session with a known next step. The next-step record is written only for `continue`, `work` and `plan`, and only when the step belongs to the asking session; a `HANDOFF.md` item writes no record at all.