@litfamily/litopencode 1.0.31 → 1.0.33

package/dist/durable-plan.d.ts

@@ -1,3 +1,7 @@
+/** The plan reaches a folder outside the project that no `Scope roots:` line names; the message says what to add. */
+export declare class PlanScopeError extends Error {
+    constructor(message: string);
+}
 export type ApprovedPlanRequest = {
     readonly schemaVersion: 1;
     readonly slug: string;
@@ -20,4 +24,4 @@ export declare function parsePlanSaveArgument(argumentsText: string): ApprovedPl
 export declare function persistApprovedPlan(projectRoot: string, request: ApprovedPlanRequest): Promise<DurablePlan>;
 export declare function resolveLatestDurablePlan(projectRoot: string): Promise<DurablePlan | undefined>;
 export declare function formatResolvedPlanNotice(plan: DurablePlan): string;
-export declare function formatSavedPlanNotice(plan: DurablePlan, replayed: boolean): string;
+export declare function formatSavedPlanNotice(plan: DurablePlan, replayed: boolean, goArmed?: boolean): string;

package/dist/durable-plan.js

@@ -1,6 +1,14 @@
 import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { describeUncoveredScopePaths, uncoveredScopePaths } from "./plan-scope-roots.js";
+/** The plan reaches a folder outside the project that no `Scope roots:` line names; the message says what to add. */
+export class PlanScopeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PlanScopeError";
+    }
+}
 const PLAN_DIRECTORY = path.join(".litopencode", "plans");
 const MAX_PLAN_BYTES = 256 * 1024;
 const MAX_ARGUMENT_BYTES = 512 * 1024;
@@ -261,6 +269,9 @@ export async function persistApprovedPlan(projectRoot, request) {
     const validationError = validateRequest(request);
     if (validationError !== "")
         throw new Error(validationError);
+    const uncovered = uncoveredScopePaths(request.markdown, projectRoot);
+    if (uncovered.length > 0)
+        throw new PlanScopeError(describeUncoveredScopePaths(uncovered));
     const body = normalizeMarkdown(request.markdown);
     const directory = path.join(projectRoot, PLAN_DIRECTORY);
     const name = `${request.slug}.md`;
@@ -343,7 +354,8 @@ export async function resolveLatestDurablePlan(projectRoot) {
 export function formatResolvedPlanNotice(plan) {
     return `Durable plan: ${plan.relativePath}. Discovery only. This does not grant start-work authority.\n\n<durable-plan>\n${plan.text}</durable-plan>`;
 }
-export function formatSavedPlanNotice(plan, replayed) {
+export function formatSavedPlanNotice(plan, replayed, goArmed = false) {
     const verb = replayed ? "Durable plan already persisted" : "Saved durable plan";
-    return `${verb}: ${plan.relativePath}. Discovery only. This does not grant start-work authority.`;
+    const go = goArmed ? " To start it, type `go` within 30 minutes in this session." : "";
+    return `${verb}: ${plan.relativePath}. Discovery only. This does not grant start-work authority.${go}`;
 }

package/dist/features.d.ts

@@ -1,5 +1,5 @@
 export type LitOpenCodeBindingKind = "agent" | "cli" | "command" | "config" | "hook" | "tool";
-export type LitOpenCodeFeatureId = "planning-start-work-loop" | "lit-litwork-activation" | "start-work" | "review-work" | "litresearch" | "durable-ledger" | "bounded-authority-lifecycle" | "agent-roster" | "lit-plan" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-install" | "search-workflow-ideas" | "lit-fetch" | "guardrails" | "lit-init" | "lit-crucible" | "lit-brainstorm" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-humanizer" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-diagram-drawer" | "lit-pptx" | "lit-typographic-motion" | "lit-docx" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
+export type LitOpenCodeFeatureId = "planning-start-work-loop" | "lit-litwork-activation" | "start-work" | "review-work" | "litresearch" | "durable-ledger" | "bounded-authority-lifecycle" | "agent-roster" | "lit-plan" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-install" | "search-workflow-ideas" | "lit-fetch" | "guardrails" | "lit-init" | "lit-crucible" | "lit-brainstorm" | "lit-hijack" | "lit-adhd" | "workflow-stack" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-humanizer" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "lit-diagram-drawer" | "lit-schematic" | "lit-pptx" | "lit-typographic-motion" | "lit-docx" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
 export type LitOpenCodeFeatureBinding = {
     readonly kind: LitOpenCodeBindingKind;
     readonly id: string;
@@ -441,6 +441,64 @@ export declare const litOpenCodeFeatures: readonly ({
         description: string;
     })[];
     verification: string[];
+} | {
+    id: "lit-hijack";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "command";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "agent";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
+} | {
+    id: "lit-adhd";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "command";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
+} | {
+    id: "workflow-stack";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
 } | {
     id: "refactor";
     title: string;
@@ -845,6 +903,27 @@ export declare const litOpenCodeFeatures: readonly ({
         description: string;
     })[];
     verification: string[];
+} | {
+    id: "lit-schematic";
+    title: string;
+    summary: string;
+    bindings: ({
+        kind: "config";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "hook";
+        id: string;
+        surface: string;
+        description: string;
+    } | {
+        kind: "cli";
+        id: string;
+        surface: string;
+        description: string;
+    })[];
+    verification: string[];
 } | {
     id: "lit-typographic-motion";
     title: string;

package/dist/features.js

@@ -532,6 +532,78 @@ export const litOpenCodeFeatures = Object.freeze([
         ],
         verification: ["node --test test/lit-brainstorm.test.mjs", "node --test test/runtime-skills.test.mjs", "node --test test/docs.test.mjs"]
     },
+    {
+        id: "lit-hijack",
+        title: "Lit Hijack",
+        summary: "Ports the mechanism in someone else's published work into the user's own skill or system through capture, licence gate, gap, source-free spec, separate build, parity proof and report, with a bundled script deciding when each phase is done.",
+        bindings: [
+            {
+                kind: "config",
+                id: "skills/lit-hijack/SKILL.md",
+                surface: "LitOpenCode native-installed managed skill",
+                description: "Ships the phase procedure with five references and the zero-dependency hijack.mjs helper, installed together so the script the skill names can run."
+            },
+            {
+                kind: "command",
+                id: "lit-hijack",
+                surface: "OpenCode command /lit-hijack",
+                description: "Makes Lit Hijack directly invocable; chat routes lit hijack, lit hijacking, lit 하이재킹 and lit 하이잭 reach the same surface."
+            },
+            {
+                kind: "agent",
+                id: "isolated implementer and optional lanes",
+                surface: "OpenCode task delegation",
+                description: "Builds from the brief alone in a separate git worktree through a write-capable task lane, with optional read-only capture, distil and verifier lanes at depth one; the lit-plan agent stays planning-only."
+            }
+        ],
+        verification: ["node --test test/lit-hijack.test.mjs", "node --test test/runtime-skills.test.mjs", "node --test test/docs.test.mjs"]
+    },
+    {
+        id: "lit-adhd",
+        title: "Lit Adhd",
+        summary: "Briefs the earlier sessions of this worktree family from a read-only collector (status, goal, real progress or known facts, done, next, roadmap), recommends one next step, and follows it on go; typed start-work, lit approve and lit deny drive the bounded run without pasted JSON.",
+        bindings: [
+            {
+                kind: "config",
+                id: "skills/lit-adhd/SKILL.md",
+                surface: "LitOpenCode native-installed managed skill",
+                description: "Ships the skill with three references and the zero-dependency rewind.mjs collector, installed together so the script the skill names can run."
+            },
+            {
+                kind: "command",
+                id: "lit-adhd",
+                surface: "OpenCode commands /lit-adhd and /lit-rewind",
+                description: "Makes the brief directly invocable; chat routes lit adhd and lit rewind reach the same surface, and a live go follows the armed step."
+            },
+            {
+                kind: "hook",
+                id: "chat.message typed prompts",
+                surface: "OpenCode chat.message and command.execute.before hooks, and the OpenCode 2 prompt hook",
+                description: "Routes go, lit approve, lit deny and start-work [plan] from the user's own root-session prompt into the existing re-entry and bounded-authority lifecycle."
+            }
+        ],
+        verification: ["node --test test/lit-adhd.test.mjs", "node --test test/adhd-go.test.mjs", "node --test test/start-work-typed.test.mjs", "node --test test/runtime-skills.test.mjs", "node --test test/docs.test.mjs"]
+    },
+    {
+        id: "workflow-stack",
+        title: "Workflow Stack",
+        summary: "Pauses a running long discipline when another lit command interrupts it, keeping its stage and real count in a per-session record, and returns to it on lit continue; the mission band and the lit-adhd collector read the same record.",
+        bindings: [
+            {
+                kind: "config",
+                id: ".litopencode/workflow-stack/<session>.json",
+                surface: "LitOpenCode runtime state",
+                description: "One small guarded file per session: link-refusing, size-capped, atomically replaced, with a stale spine never resumed."
+            },
+            {
+                kind: "hook",
+                id: "chat.message activation memory",
+                surface: "OpenCode chat.message hook and the OpenCode 2 prompt hook",
+                description: "Pushes an interjected discipline over the running one, appends the paused-at line, and resumes the paused discipline on lit continue or go."
+            }
+        ],
+        verification: ["node --test test/workflow-stack.test.mjs", "node --test test/workflow-interleave.test.mjs", "node --test test/runtime-skills.test.mjs"]
+    },
     {
         id: "refactor",
         title: "Refactor",
@@ -1145,6 +1217,38 @@ export const litOpenCodeFeatures = Object.freeze([
         ],
         verification: ["node --test test/lit-diagram-drawer.test.mjs", "npm run check:managed-skill-manifest", "npm run check:pack-payload"]
     },
+    {
+        id: "lit-schematic",
+        title: "Lit Schematic",
+        summary: "Installs an OpenCode native skill with a plain-Node drawing kit, symbol library, QA gate, renderer and worked examples for P&IDs, apparatus figures and isometric cutaways, and routes bounded lit drawing requests to it.",
+        bindings: [
+            {
+                kind: "config",
+                id: "skills/lit-schematic/SKILL.md",
+                surface: "OpenCode native skill picker",
+                description: "Selects the physical-schematic workflow and its complete managed skill tree; no dedicated slash command or bare-id chat route is registered."
+            },
+            {
+                kind: "hook",
+                id: "lit-task schematic drawing intent",
+                surface: "OpenCode chat.message activation",
+                description: "Directs bounded lit P&ID, PFD, apparatus and cutaway drawing requests to load the native skill before drawing, ahead of the diagram, film and Office hand-offs; questions, reviews, charts and reports stay inert."
+            },
+            {
+                kind: "cli",
+                id: "litopencode install",
+                surface: "LitOpenCode managed native skill installer",
+                description: "Installs every hash-pinned reference, script, kit module and example."
+            },
+            {
+                kind: "cli",
+                id: "litopencode doctor",
+                surface: "LitOpenCode managed native skill doctor",
+                description: "Verifies the exact installed file closure; the skill's own doctor script reports Chrome, fonts and encoders without installing tools."
+            }
+        ],
+        verification: ["node --test test/lit-schematic.test.mjs test/lit-schematic-symbols.test.mjs test/lit-schematic-outputs.test.mjs", "npm run check:managed-skill-manifest", "npm run check:pack-payload"]
+    },
     {
         id: "lit-typographic-motion",
         title: "Film director",
@@ -1154,7 +1258,7 @@ export const litOpenCodeFeatures = Object.freeze([
             { kind: "hook", id: "lit-task motion-video intent", surface: "OpenCode chat.message activation", description: "Routes bounded film requests before slide and interface guidance with a neutral film context." },
             { kind: "hook", id: "tool.execute.after", surface: "OpenCode tool.execute.after hook", description: "Records each read of a film's or a cover's stills so the done check can confirm the frames were viewed." },
             { kind: "cli", id: "litopencode motion-runtime install|status", surface: "LitOpenCode runtime", description: "Pre-warms pinned dependencies and fonts outside the render session." },
-            { kind: "cli", id: "litopencode doctor", surface: "LitOpenCode doctor", description: "Reports Chrome, ffmpeg, WebGL2 tier, software warning, pre-warm status and the cover encoder." }
+            { kind: "cli", id: "litopencode doctor", surface: "LitOpenCode doctor", description: "Reports Chrome, ffmpeg, WebGL2 tier, software warning, pre-warm status, the cover encoder and, as information only, whether Blender is installed." }
         ],
         verification: ["node --test test/lit-typographic-motion.test.mjs", "node --test test/motion-cover.test.mjs", "npm run check:managed-skill-manifest", "npm run check:pack-payload"]
     },

package/dist/hooks.js

@@ -3,6 +3,7 @@ import { dynamicRulesForPaths } from "./rules/hooks.js";
 import { applyLitOpenCodePostEditHook, applyLitOpenCodeToolAfterHook, applyLitOpenCodeToolBeforeHook, applyTaskRecursionGuard, mutatedFilePaths } from "./tool-guards.js";
 import { captureKnowledgeEvent } from "./knowledge.js";
 import { recordMotionImageRead } from "./motion-image-reads.js";
+import { markLiveness } from "./session-liveness.js";
 export function createToolExecuteBeforeHook(options = {}) {
     return async (input, output) => {
         await applyTaskRecursionGuard(input, options.getSession);
@@ -13,6 +14,8 @@ export function createToolExecuteBeforeHook(options = {}) {
 }
 export function createToolExecuteAfterHook(options = {}) {
     return async (input, output) => {
+        if (options.projectRoot !== undefined)
+            await markLiveness(options.projectRoot, input.sessionID, "alive");
         applyLitOpenCodeToolAfterHook(input, output);
         applyLitOpenCodePostEditHook(input, output);
         recordMotionImageRead(input, options.projectRoot);

package/dist/ledger.js

@@ -407,7 +407,18 @@ async function writeEvidenceLedger(projectRoot, state) {
         await removeIfPresent(tempFile);
         throw new LedgerIoError(`Failed to write goals.json: ${error instanceof Error ? error.message : String(error)}`);
     }
-    await fs.writeFile(paths.briefFile, renderEvidenceBrief(state), "utf8");
+    // The brief is replaced through a temp file and a rename, so a link planted at brief.md is swapped out,
+    // never written through.
+    goalsTempCounter += 1;
+    const briefTemp = path.join(paths.litLoopDir, `${goalsTempPrefix}${process.pid}-${goalsTempCounter}`);
+    try {
+        await fs.writeFile(briefTemp, renderEvidenceBrief(state), { encoding: "utf8", flag: "wx" });
+        await fs.rename(briefTemp, paths.briefFile);
+    }
+    catch (error) {
+        await removeIfPresent(briefTemp);
+        throw new LedgerIoError(`Failed to write brief.md: ${error instanceof Error ? error.message : String(error)}`);
+    }
     return state;
 }
 function evidenceMutationPaths(projectRoot) {

package/dist/plan-scope-roots.d.ts

@@ -0,0 +1,23 @@
+import type { SemanticAuthorityAction } from "./bounded-authority.ts";
+export type ScopeRoot = {
+    readonly root: string;
+    readonly actions: readonly SemanticAuthorityAction[];
+};
+export type UncoveredScopePath = {
+    readonly path: string;
+    readonly line: string;
+} | {
+    readonly path: string;
+    readonly problem: string;
+};
+/**
+ * `Scope roots:` lines outside code fences, with paths resolved against the project. A line naming a broad
+ * folder, or any action other than read, write and execute, grants nothing.
+ */
+export declare function parseScopeRoots(planText: string, projectRoot: string): ScopeRoot[];
+/**
+ * Each outside folder the plan's todo section reaches that neither the project nor a `Scope roots:` line
+ * covers, once per folder: with the exact line to paste, or with a problem when only a broad folder exists.
+ */
+export declare function uncoveredScopePaths(planText: string, projectRoot: string): UncoveredScopePath[];
+export declare function describeUncoveredScopePaths(entries: readonly UncoveredScopePath[]): string;

package/dist/plan-scope-roots.js

@@ -0,0 +1,116 @@
+import { realpathSync, statSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const scopeLine = /^Scope roots?:[ \t]*(\S+)[ \t]*\(([^()\r\n]+)\)[ \t]*$/u;
+const semanticActions = new Set(["read", "write", "execute"]);
+// Two or more absolute segments; a lone `/` or a relative path is not a folder the work reaches.
+const absolutePath = /(?<![\w.~/-])\/[\w.@+%,=~-]+(?:\/[\w.@+%,=~-]+)+\/?/gu;
+function linesOutsideFences(text) {
+    const kept = [];
+    let fence;
+    for (const line of text.split(/\r?\n/u)) {
+        const marker = /^\s{0,3}(`{3,}|~{3,})/u.exec(line)?.[1];
+        if (marker !== undefined && (fence === undefined || marker.startsWith(fence))) {
+            fence = fence === undefined ? marker : undefined;
+            continue;
+        }
+        if (fence === undefined)
+            kept.push(line);
+    }
+    return kept;
+}
+/** Real path of the deepest existing ancestor, with the missing tail appended unchanged. */
+function realish(target) {
+    const missing = [];
+    for (let at = path.resolve(target);; at = path.dirname(at)) {
+        try {
+            return path.join(realpathSync(at), ...missing.reverse());
+        }
+        catch {
+            if (path.dirname(at) === at)
+                return path.resolve(target);
+            missing.push(path.basename(at));
+        }
+    }
+}
+function nearestDirectory(target) {
+    for (let at = path.resolve(target);; at = path.dirname(at)) {
+        try {
+            if (statSync(at).isDirectory())
+                return realish(at);
+        }
+        catch {
+            // Not created yet; try the parent.
+        }
+        if (path.dirname(at) === at)
+            return at;
+    }
+}
+/** The filesystem root, a top-level folder or the home folder itself is too broad to grant. */
+function tooBroad(directory) {
+    const parent = path.dirname(directory);
+    return parent === directory || path.dirname(parent) === parent || directory === realish(os.homedir());
+}
+function within(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+/**
+ * `Scope roots:` lines outside code fences, with paths resolved against the project. A line naming a broad
+ * folder, or any action other than read, write and execute, grants nothing.
+ */
+export function parseScopeRoots(planText, projectRoot) {
+    const roots = [];
+    for (const line of linesOutsideFences(planText)) {
+        const match = scopeLine.exec(line.trim());
+        if (match === null)
+            continue;
+        const actions = match[2].split(",").map((action) => action.trim().toLowerCase());
+        if (actions.length === 0 || !actions.every((action) => semanticActions.has(action)))
+            continue;
+        const root = path.resolve(projectRoot, match[1]);
+        if (tooBroad(realish(root)))
+            continue;
+        roots.push({ root, actions: [...new Set(actions)] });
+    }
+    return roots;
+}
+/** Absolute paths of a todo line; a code span holding a command (it has a space) is data, not a reach. */
+function pathMentions(line) {
+    const spansAsText = line.replace(/`([^`]*)`/gu, (_, span) => (/\s/u.test(span.trim()) ? " " : ` ${span.trim()} `));
+    return (spansAsText.match(absolutePath) ?? []).map((mention) => mention.replace(/[.,:;)]+$/u, ""));
+}
+/**
+ * Each outside folder the plan's todo section reaches that neither the project nor a `Scope roots:` line
+ * covers, once per folder: with the exact line to paste, or with a problem when only a broad folder exists.
+ */
+export function uncoveredScopePaths(planText, projectRoot) {
+    const project = realish(projectRoot);
+    const covered = [project, ...parseScopeRoots(planText, project).map((scope) => realish(scope.root))];
+    const found = new Map();
+    let inTodos = false;
+    for (const line of linesOutsideFences(planText)) {
+        const heading = /^#{1,2}\s+(.+?)\s*$/u.exec(line)?.[1];
+        if (heading !== undefined)
+            inTodos = /^todos\b/iu.test(heading);
+        if (!inTodos)
+            continue;
+        for (const mention of pathMentions(line)) {
+            const real = realish(mention);
+            if (covered.some((root) => within(root, real)))
+                continue;
+            const directory = nearestDirectory(mention);
+            if (found.has(directory))
+                continue;
+            found.set(directory, tooBroad(directory)
+                ? { path: mention, problem: `${mention} is outside the project; name a narrower existing folder on a Scope roots line.` }
+                : { path: mention, line: `Scope roots: ${directory} (read)` });
+        }
+    }
+    return [...found.values()];
+}
+export function describeUncoveredScopePaths(entries) {
+    return entries.map((entry) => ("line" in entry
+        ? `${entry.path} is outside the project and no Scope roots line covers it; add this line to the plan: ${entry.line}`
+        : entry.problem)).join(" ");
+}

package/dist/restart-notice.d.ts

@@ -0,0 +1,7 @@
+/** The newest stable installed version strictly newer than the loaded one, or undefined. */
+export declare function restartVersion(loaded: unknown, installed: readonly unknown[]): string | undefined;
+/**
+ * What is installed now: the package.json version under `packageRoot`, then the target of an automatic
+ * update whose receipt says it was installed. Unreadable or malformed sources are left out.
+ */
+export declare function readInstalledVersions(packageRoot: string, homeDir?: string): Promise<string[]>;

package/dist/restart-notice.js

@@ -0,0 +1,40 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { readAutoUpdateReceipt } from "./cli/auto-update.js";
+import { compareStableVersions } from "./cli/update-notifier.js";
+// OpenCode keeps running the plugin code it loaded at start, so an update installed meanwhile (by the
+// automatic update at start, or by the CLI from a terminal) waits for the next start. The TUI compares
+// the version it loaded with what is installed now and, when the install is newer, asks for a restart.
+// It never starts anything itself: inside the OpenCode host, `process.execPath` is the host binary.
+/** The newest stable installed version strictly newer than the loaded one, or undefined. */
+export function restartVersion(loaded, installed) {
+    let newest;
+    for (const candidate of installed) {
+        if (compareStableVersions(candidate, loaded) !== 1)
+            continue;
+        if (newest === undefined || compareStableVersions(candidate, newest) === 1)
+            newest = candidate;
+    }
+    return newest;
+}
+/**
+ * What is installed now: the package.json version under `packageRoot`, then the target of an automatic
+ * update whose receipt says it was installed. Unreadable or malformed sources are left out.
+ */
+export async function readInstalledVersions(packageRoot, homeDir = os.homedir()) {
+    const versions = [];
+    try {
+        const parsed = JSON.parse(await fs.readFile(path.join(packageRoot, "package.json"), "utf8"));
+        const version = typeof parsed === "object" && parsed !== null ? parsed.version : undefined;
+        if (typeof version === "string")
+            versions.push(version);
+    }
+    catch {
+        // No readable package.json; the receipt may still say what was installed.
+    }
+    const receipt = await readAutoUpdateReceipt(homeDir).catch(() => undefined);
+    if (receipt !== undefined && receipt.status === "updated" && receipt.targetVersion !== undefined)
+        versions.push(receipt.targetVersion);
+    return versions;
+}

package/dist/secret-shapes.js

@@ -25,13 +25,13 @@ const secretShapeAlternatives = [
     String.raw `(?<![A-Za-z0-9_])eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+(?![A-Za-z0-9_])`,
     String.raw `\b(?:authorization|proxy-authorization)\s*:\s*\S+\s+\S+`,
     String.raw `\b(?:bearer|basic)\s+[A-Za-z0-9._~+/=-]{8,}(?=$|[^A-Za-z0-9._~+/=-])`,
-    String.raw `\b(?:password|passwd|secret|token|api[_-]?key|access[_-]?token)\s*[:=]\s*[^\s,;]{8,}`,
-    String.raw `\b[A-Za-z][A-Za-z0-9]*(?:[_-][A-Za-z0-9]+)*[_-](?:token|secret|key)(?:[_-][A-Za-z0-9]+)*\s*[:=]\s*[^\s,;]{8,}`,
-    String.raw `\b_?auth(?:[_-]?token)?\s*[:=]\s*[^\s,;]{8,}`,
+    String.raw `\b(?:password|passwd|secret|token|api[_-]?key|access[_-]?token)["']?\s*[:=]\s*[^\s,;]{8,}`,
+    String.raw `\b[A-Za-z][A-Za-z0-9]*(?:[_-][A-Za-z0-9]+)*[_-](?:token|secret|key)(?:[_-][A-Za-z0-9]+)*["']?\s*[:=]\s*[^\s,;]{8,}`,
+    String.raw `\b_?auth(?:[_-]?token)?["']?\s*[:=]\s*[^\s,;]{8,}`,
     String.raw `(?<![A-Za-z0-9+.-])(?:[A-Za-z][A-Za-z0-9+.-]*:)?\/\/[^/?#\s]+@`
 ];
-const shortKeyValueSecretShape = /(?<![A-Za-z0-9_])(?:password|passwd|passphrase|secret|token|api[_-]?key|access[_-]?token|auth[_-]?token|[A-Za-z][A-Za-z0-9]*(?:[_-][A-Za-z0-9]+)*[_-](?:password|passwd|passphrase|secret|token|key)(?:[_-][A-Za-z0-9]+)*)\s*=\s*(?:"[^"\r\n]+"|'[^'\r\n]+'|[^\s,;]+)/iu;
-const shortUppercaseColonSecretShape = /(?<![A-Za-z0-9_])(?:PASSWORD|PASSWD|PASSPHRASE|SECRET|TOKEN|API[_-]?KEY|ACCESS[_-]?TOKEN|AUTH[_-]?TOKEN|[A-Z][A-Z0-9]*(?:[_-][A-Z0-9]+)*[_-](?:PASSWORD|PASSWD|PASSPHRASE|SECRET|TOKEN|KEY)(?:[_-][A-Z0-9]+)*)\s*:\s*(?:"[^"\r\n]+"|'[^'\r\n]+'|[^\s,;]+)/u;
+const shortKeyValueSecretShape = /(?<![A-Za-z0-9_])(?:password|passwd|passphrase|secret|token|api[_-]?key|access[_-]?token|auth[_-]?token|[A-Za-z][A-Za-z0-9]*(?:[_-][A-Za-z0-9]+)*[_-](?:password|passwd|passphrase|secret|token|key)(?:[_-][A-Za-z0-9]+)*)["']?\s*=\s*(?:"[^"\r\n]+"|'[^'\r\n]+'|[^\s,;]+)/iu;
+const shortUppercaseColonSecretShape = /(?<![A-Za-z0-9_])(?:PASSWORD|PASSWD|PASSPHRASE|SECRET|TOKEN|API[_-]?KEY|ACCESS[_-]?TOKEN|AUTH[_-]?TOKEN|[A-Z][A-Z0-9]*(?:[_-][A-Z0-9]+)*[_-](?:PASSWORD|PASSWD|PASSPHRASE|SECRET|TOKEN|KEY)(?:[_-][A-Z0-9]+)*)["']?\s*:\s*(?:"[^"\r\n]+"|'[^'\r\n]+'|[^\s,;]+)/u;
 /** The guarded credential shape. Exported so a consumer can read it, never widen it. */
 export const secretShape = new RegExp(`(?:${secretShapeAlternatives.join("|")})`, "iu");
 const lowercaseTokenShape = /\btoken\s+[A-Za-z0-9._~+/=-]{8,}(?=$|[^A-Za-z0-9._~+/=-])/u;

package/dist/server.js

@@ -11,6 +11,7 @@ import { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks
 import { createLogger } from "./logger.js";
 import { createIgnitionState } from "./ignition.js";
 import { createSessionLookup } from "./session-lineage.js";
+import { markLiveness } from "./session-liveness.js";
 import { applyCompactionRuleReset, applyStaticRuleInjection } from "./rules/hooks.js";
 import { defaultOpenCodeConfigRoot } from "./state.js";
 import { litOpenCodeTools } from "./tools.js";
@@ -78,7 +79,10 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
                 registerLitOpenCodeAgents(config, loaded.config);
             },
             event: async (eventInput) => {
+                if (eventInput.event.type === "session.idle")
+                    await markLiveness(root, eventInput.event.properties.sessionID, "idle");
                 if (eventInput.event.type === "session.deleted") {
+                    await markLiveness(root, eventInput.event.properties.info.id, "ended");
                     ignitionState.clear(eventInput.event.properties.info.id);
                     activationMemory.forget(eventInput.event.properties.info.id);
                     trustedCommandActivations.delete(eventInput.event.properties.info.id);

package/dist/session-liveness.d.ts

@@ -0,0 +1,20 @@
+export type LivenessState = "alive" | "idle" | "ended";
+export type LivenessRecord = {
+    readonly version: 1;
+    readonly sessionId: string;
+    readonly state: LivenessState;
+    readonly at: string;
+    readonly herdrPane: string | null;
+};
+export declare const livenessRepeatMs = 30000;
+export declare function livenessFile(projectRoot: string, sessionID: string): string;
+/** The session's record, or undefined when the id is unsafe or the file is missing, a link, oversized or malformed. */
+export declare function readLivenessSync(projectRoot: string, sessionID: string): LivenessRecord | undefined;
+/**
+ * Records the session's state; true when a record was written. Never throws: a missing project state folder,
+ * a linked folder or record, an unsafe id or a failed write all return false so the calling hook carries on.
+ */
+export declare function markLiveness(projectRoot: string, sessionID: string, state: LivenessState, options?: {
+    readonly now?: number;
+    readonly env?: NodeJS.ProcessEnv;
+}): Promise<boolean>;