@litfamily/litopencode 1.0.25 → 1.0.27

package/dist/cli/doctor.js

@@ -16,8 +16,73 @@ import { inspectLspCapability } from "./lsp-capability.js";
 import { probeMotionRuntime } from "./motion-runtime.js";
 import { isLitOpenCodeEntry } from "./plugin-mutation.js";
 import { inspectTuiPlugin } from "./tui-config.js";
-import { jevSkillHintDoctorLine } from "../jev-skill-hint.js";
-import { autoUpdateInstallLockPath, autoUpdateJournalPath, autoUpdateReceiptPath, isAutoUpdateDisabled, readAutoUpdateReceipt } from "./auto-update.js";
+import { autoUpdateCheckPath, autoUpdateInstallLockPath, autoUpdateJournalPath, autoUpdateReceiptPath, isAutoUpdateDisabled, readAutoUpdateCheck, readAutoUpdateReceipt } from "./auto-update.js";
+const updateNow = "npx @litfamily/litopencode@latest install";
+/** Each row says what a cause means and the one thing to do about it. */
+const autoUpdateRemedies = [
+    { cause: "next-start", meaning: "A newer version is installed, but the OpenCode that installed it still runs the old one.", remedy: "Quit and start OpenCode again." },
+    { cause: "offline", meaning: "OpenCode could not reach the npm registry at its last start, so nothing was checked.", remedy: "Check the network or proxy. The next OpenCode start checks again." },
+    { cause: "backoff", meaning: "The last update to this version failed and was undone, so OpenCode waits a day before trying it again.", remedy: `Run \`${updateNow}\` to update now, or wait a day or for a newer release.` },
+    { cause: "timeout", meaning: "A step of the last update ran past its 30 second limit and was undone.", remedy: `Usually a slow network. Run \`${updateNow}\` once while online.` },
+    { cause: "missing-command", meaning: "npm or node was not on the PATH OpenCode started with, so the update could not run.", remedy: `Install Node.js where OpenCode can find it, or update by hand with \`${updateNow}\`.` },
+    { cause: "install-failed", meaning: "The last update failed and the old setup was put back.", remedy: `Run \`${updateNow}\` and read what it prints.` },
+    { cause: "stopped", meaning: "The last update could not prove the old setup came back, so the plugin refuses to load.", remedy: `Run \`${updateNow}\`. The kept backup folder holds the old files.` },
+    { cause: "lock-busy", meaning: "Another OpenCode start held the update lock.", remedy: "Nothing to do; the next start tries again. If it repeats with no OpenCode open, delete the lock file." },
+    { cause: "opted-out", meaning: "Automatic update is switched off by --no-auto-update or by CI, NO_UPDATE_NOTIFIER, LITOPENCODE_NO_AUTO_UPDATE or LITOPENCODE_NO_UPDATE_CHECK.", remedy: "Remove the switch from the environment OpenCode starts in." },
+    { cause: "local-checkout", meaning: "The plugin runs from a git checkout, which is never updated automatically.", remedy: "Pull the checkout with git, or install the published package." }
+];
+const skipCauses = {
+    "registry-unavailable": "offline",
+    backoff: "backoff",
+    "install-lock-busy": "lock-busy",
+    disabled: "opted-out",
+    "local-checkout": "local-checkout"
+};
+/**
+ * Doctor reads the receipt and the record each OpenCode start leaves behind. It
+ * cannot see inside a running OpenCode, so "running" means the last start seen.
+ */
+export async function inspectAutoUpdate(input) {
+    const enabled = !isAutoUpdateDisabled(input.env);
+    const receipt = await readAutoUpdateReceipt(input.homeDir);
+    const lastCheck = await readAutoUpdateCheck(input.homeDir);
+    const summary = receipt === undefined || receipt.status === "unreadable" ? undefined : receipt;
+    let cause = null;
+    let nextStart = null;
+    if (summary !== undefined && (summary.status === "failed" || (summary.status === "rolled-back" && !(summary.rollbackOk && summary.priorStateVerified && summary.stagedStateKnown)))) {
+        cause = "stopped";
+    }
+    else if (lastCheck?.reason !== undefined && skipCauses[lastCheck.reason] !== undefined) {
+        cause = skipCauses[lastCheck.reason];
+    }
+    else if (lastCheck?.status === "rolled-back" && summary?.failure !== undefined) {
+        cause = summary.failure.missingCommand ? "missing-command" : summary.failure.timedOut ? "timeout" : "install-failed";
+    }
+    else if (summary?.status === "updated" && summary.targetVersion !== undefined) {
+        const running = lastCheck?.runningVersion ?? summary.currentVersion;
+        if (running !== undefined && running !== summary.targetVersion) {
+            cause = "next-start";
+            nextStart = `installed ${summary.targetVersion}, running ${running}: takes effect the next time OpenCode starts`;
+        }
+    }
+    if (cause === null && !enabled)
+        cause = "opted-out";
+    return {
+        enabled,
+        state: cause === null ? (lastCheck === undefined ? "unknown" : "current") : cause === "next-start" ? "next-start" : "attention",
+        cause,
+        nextStart,
+        pinnedVersion: input.pinnedVersion,
+        lastCheck: lastCheck ?? null,
+        proof: "Doctor reads files only. It cannot see which version a running OpenCode has loaded; restarting OpenCode is the sure way.",
+        remedies: autoUpdateRemedies,
+        installLock: autoUpdateInstallLockPath(input.homeDir),
+        journal: autoUpdateJournalPath(input.homeDir),
+        receipt: autoUpdateReceiptPath(input.homeDir),
+        check: autoUpdateCheckPath(input.homeDir),
+        lastReceipt: receipt
+    };
+}
 function pluginSpec(metadata) {
     return metadata.name + "@" + metadata.version;
 }
@@ -164,7 +229,6 @@ export async function doctor(root) {
                 warnings: autoHandoffWarnings
             },
             motion,
-            jevSkillHint: jevSkillHintDoctorLine(process.env),
             config: {
                 source: loaded.source,
                 sources: loaded.sources,
@@ -204,13 +268,10 @@ export async function doctor(root) {
                     derivedTruthFiles: false
                 }
             },
-            autoUpdate: {
-                enabled: !isAutoUpdateDisabled(process.env),
-                installLock: autoUpdateInstallLockPath(),
-                journal: autoUpdateJournalPath(),
-                receipt: autoUpdateReceiptPath(),
-                lastReceipt: await readAutoUpdateReceipt()
-            },
+            autoUpdate: await inspectAutoUpdate({
+                env: process.env,
+                pinnedVersion: installPlugin.configured?.startsWith(`${metadata.name}@`) === true ? installPlugin.configured.slice(metadata.name.length + 1) : null
+            }),
             install: {
                 ok: installPlugin.ok && commandAliases.ok && nativeSkills.ok,
                 plugin: installPlugin,

package/dist/cli/managed-skill-assets.js

@@ -78,12 +78,12 @@ export function isRecursivelyManagedSkill(id) {
 // surfaces the skill at the moment it is needed. The record is total by type: adding a runtime skill
 // id without writing its trigger is a compile error, not a silent fallback.
 const skillDiscoveryDescriptions = Object.freeze({
-    "workflow-loop": "Trigger when the user wants a multi-step LitOpenCode work loop started, resumed, or kept running — bare `lit`, `/lit`, `/litwork`, \"keep going\", \"continue the loop\" — or when a request needs goal binding, ordered execution, and ledger-backed progress across turns instead of one answer.",
+    "workflow-loop": "Trigger when the user wants a multi-step LitOpenCode work loop started, resumed, or kept running — bare `lit`, `/lit`, `/litwork`, \"keep going\", \"continue the loop\" — or when a request needs goal binding, ordered execution, and ledger-backed progress across turns instead of one answer. Also trigger when one request hands over a whole feature, fix, or ticket to carry through to done — build it, add tests, verify against each acceptance condition and on the real user-facing path, clean up temporary artifacts, then report what changed (\"start to finish\", \"end to end\", \"see it through\", \"처음부터 끝까지\", \"끝까지 해줘\"). Do not trigger for a question, an explanation, or a one-line snippet.",
     "durable-litgoal": "Trigger when work needs an objective that outlives the current turn: binding a goal with checkable criteria, reading or appending the `.litopencode/litgoal` ledger, resuming a schema-3 bounded-authority work record, or answering \"what was I working on\" from durable state rather than chat memory.",
     "agent-roster": "Trigger when deciding which OpenCode agent should do the work, and again the moment work is about to be split across several lanes at once — before delegating through the task tool, when a request fans out into planning, implementation, review, research, or verification lanes, or when the user asks which agents exist and what each is permitted to touch. Delegation here is depth-one, so lanes need non-overlapping slices, explicit per-lane state, and a completion claim that aggregates every lane's evidence rather than summarising it.",
     "lit-plan": "Trigger when the user asks for a plan, checklist, approach, or design before implementation, or when a request is large or risky enough that execution must not start until scope, non-goals, ordered action/output/verification items, and a falsifiable DoneClaim are agreed. Do not trigger to perform the work itself.",
     "start-work": "Trigger when an approved plan or an explicit go-ahead already exists and implementation should begin or resume — \"start work\", \"execute the plan\", \"pick up where we left off\" — so the loop runs in verifiable slices with delegation lanes, evidence, and an independent verifier before any completion claim.",
-    "review-work": "Trigger when something must be judged rather than produced: a draft plan needing a PASS / ITERATE / NEEDS-CONTEXT achievability verdict, or finished work needing the five-lane scope-diff, tests-evidence, package-payload, security-provenance, and real-surface-docs check before it can be called done.",
+    "review-work": "Trigger when something must be judged rather than produced: a patch, diff, PR, branch, or set of open changes to inspect for real defects, risks, or merge readiness (\"review this\", \"is this safe to merge\", \"point out anything risky\", \"리뷰해줘\", \"검토해줘\", \"합쳐도 될지 봐줘\"), where findings need file-and-line evidence, a reproduction path, and severity; a draft plan needing a PASS / ITERATE / NEEDS-CONTEXT achievability verdict; or finished work needing the five-lane scope-diff, tests-evidence, package-payload, security-provenance, and real-surface-docs check before it can be called done. When fixes are also asked for, the review comes first. Do not trigger for a general question about git, merging, or how code review works.",
     litresearch: "Trigger when a question needs sourced investigation rather than recall — comparing options, confirming whether a library, API, or behavior actually works as claimed, gathering public evidence across several sources — so verified facts, hypotheses, contradictions, and residual uncertainty stay separated before a verdict.",
     "reference-benchmark-claims": "Trigger before writing any comparative or superiority claim about this package — \"faster than\", \"better than\", \"always wins\", \"무조건\" — so the wording is classified against the measured benchmark suite and universal all-task claims are blocked rather than shipped.",
     "native-goal-verdict": "Trigger when someone assumes the OpenCode host has a built-in goal primitive — asking for `/goal`, native goal tracking, or host-side objective state — so the answer reflects the verified host capability and routes to LitOpenCode durable goal state instead of promising an integration that does not exist.",

package/dist/deliverable-hedge-guard.js

@@ -57,6 +57,116 @@ function toolText(input) {
         return { file: candidate, unavailable: "new text exceeds scan limit" };
     return { file: candidate, value: values[0] };
 }
+const patchTools = new Set(["apply_patch", "patch"]);
+function patchTextOf(input) {
+    if (!patchTools.has(input.tool) || !isRecord(input.args))
+        return undefined;
+    const value = input.args.patchText;
+    return typeof value === "string" ? value : undefined;
+}
+// Reads the apply_patch envelope: `*** Add File:` bodies are `+` lines, `*** Update File:` carries an optional
+// `*** Move to:` and `@@` chunks of ` `, `-` and `+` lines. Delete hunks remove text and are not scanned.
+function parsePatch(patchText) {
+    const lines = patchText.split(/\r?\n/u);
+    const begin = lines.findIndex((line) => line.trim() === "*** Begin Patch");
+    const end = lines.findIndex((line) => line.trim() === "*** End Patch");
+    if (begin < 0 || end < 0 || begin >= end)
+        throw new Error("patch text has no Begin/End markers");
+    const isHeader = (line) => /^\*\*\* (?:Add|Update|Delete) File:/u.test(line);
+    const files = [];
+    let index = begin + 1;
+    while (index < end) {
+        const line = lines[index];
+        if (line.startsWith("*** Add File:")) {
+            const body = [];
+            index += 1;
+            while (index < end && !isHeader(lines[index])) {
+                if (lines[index].startsWith("+"))
+                    body.push(lines[index].slice(1));
+                index += 1;
+            }
+            files.push({ kind: "add", file: line.slice(13).trim(), contents: body.join("\n"), chunks: [], added: body });
+        }
+        else if (line.startsWith("*** Update File:")) {
+            const file = line.slice(16).trim();
+            let moveTo;
+            index += 1;
+            if (index < end && lines[index].startsWith("*** Move to:")) {
+                moveTo = lines[index].slice(12).trim();
+                index += 1;
+            }
+            const chunks = [];
+            const added = [];
+            let before = [];
+            let after = [];
+            let open = false;
+            const close = () => {
+                if (open)
+                    chunks.push({ before, after });
+                before = [];
+                after = [];
+                open = false;
+            };
+            while (index < end && !isHeader(lines[index])) {
+                const row = lines[index];
+                if (row.startsWith("@@"))
+                    close();
+                else if (row.startsWith("*** End of File")) { /* marker only */ }
+                else if (row.startsWith("+")) {
+                    open = true;
+                    after.push(row.slice(1));
+                    added.push(row.slice(1));
+                }
+                else if (row.startsWith("-")) {
+                    open = true;
+                    before.push(row.slice(1));
+                }
+                else {
+                    open = true;
+                    const text = row.startsWith(" ") ? row.slice(1) : row;
+                    before.push(text);
+                    after.push(text);
+                }
+                index += 1;
+            }
+            close();
+            files.push({ kind: "update", file, moveTo: moveTo === "" ? undefined : moveTo, contents: "", chunks, added });
+        }
+        else {
+            index += 1;
+        }
+    }
+    return files;
+}
+function applyChunks(oldText, chunks) {
+    const lines = oldText.split("\n");
+    const trailing = lines.length > 1 && lines[lines.length - 1] === "";
+    if (trailing)
+        lines.pop();
+    let cursor = 0;
+    for (const chunk of chunks) {
+        if (chunk.before.length === 0) {
+            lines.push(...chunk.after);
+            cursor = lines.length;
+            continue;
+        }
+        const matches = (at, normalize) => chunk.before.every((text, offset) => at + offset < lines.length && normalize(lines[at + offset]) === normalize(text));
+        let found = -1;
+        for (const normalize of [(text) => text, (text) => text.trimEnd(), (text) => text.trim()]) {
+            for (let at = cursor; at + chunk.before.length <= lines.length && found < 0; at += 1) {
+                if (matches(at, normalize))
+                    found = at;
+            }
+            if (found >= 0)
+                break;
+        }
+        if (found < 0)
+            throw new Error("patch chunk was not found in the current file");
+        lines.splice(found, chunk.before.length, ...chunk.after);
+        cursor = found + chunk.after.length;
+    }
+    return lines.join("\n") + (trailing ? "\n" : "");
+}
 function runJsonProcess(command, args, input, timeoutMs) {
     return new Promise((resolve, reject) => {
         const child = spawn(command, [...args], { shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
@@ -186,8 +296,71 @@ export function createDeliverableHedgeGuard(options) {
     const timeoutMs = options.timeoutMs ?? defaultTimeoutMs;
     const scan = options.scan ?? ((request) => defaultScan(request, timeoutMs));
     const pending = new Map();
+    async function scanTarget(file, oldText, newText) {
+        if (Buffer.byteLength(newText, "utf8") > maxTextBytes)
+            throw new Error("new text exceeds scan limit");
+        const findings = await scan({ file, oldText, newText });
+        const block = findings.filter((finding) => finding.severity === "block");
+        if (block.length > 0) {
+            const first = block[0];
+            throw new Error(`LIT_HUMANIZER_BLOCKED rule=${first.rule} line=${first.line} path=${displayPath(file)}. Revise the new text before saving.`);
+        }
+        return findings.length;
+    }
+    // An apply_patch call can add several files; each deliverable-path target gets the same per-file scan as write
+    // and edit. A chunk that cannot be located in the current file is scanned as appended text instead, so an added
+    // pledge is still refused (the host rejects a patch whose context does not match, so nothing is saved either way).
+    async function guardPatch(callID, patchText) {
+        try {
+            if (Buffer.byteLength(patchText, "utf8") > maxTextBytes)
+                throw new Error("patch text exceeds scan limit");
+            let warned = 0;
+            let warnedFile = "";
+            for (const entry of parsePatch(patchText)) {
+                const target = entry.moveTo ?? entry.file;
+                if (isInternalPath(target) || !readerFacingExtensions.has(path.extname(target).toLowerCase()))
+                    continue;
+                const oldText = await existingText(projectRoot, entry.kind === "add" ? target : entry.file);
+                let newText;
+                if (entry.kind === "add")
+                    newText = entry.contents;
+                else {
+                    try {
+                        newText = applyChunks(oldText, entry.chunks);
+                    }
+                    catch {
+                        newText = `${oldText}\n${entry.added.join("\n")}`;
+                    }
+                }
+                const count = await scanTarget(target, oldText, newText);
+                if (count > 0 && warned === 0)
+                    warnedFile = target;
+                warned += count;
+            }
+            if (warned > 0) {
+                remember(pending, callID, {
+                    tier: "warn",
+                    message: `LIT_HUMANIZER_WARN findings=${warned} path=${displayPath(warnedFile)}. Review the new wording; keep any accurate, useful warning.`
+                });
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith("LIT_HUMANIZER_BLOCKED"))
+                throw error;
+            remember(pending, callID, {
+                tier: "unavailable",
+                message: `LIT_HUMANIZER_GUARD_UNAVAILABLE: ${oneLine(error)}; write allowed without this check.`
+            });
+        }
+    }
     return {
         async before(input) {
+            const patchText = patchTextOf(input);
+            if (patchText !== undefined) {
+                pending.delete(input.callID);
+                await guardPatch(input.callID, patchText);
+                return;
+            }
             const text = toolText(input);
             if (text === undefined)
                 return;
@@ -204,18 +377,11 @@ export function createDeliverableHedgeGuard(options) {
                 const newText = input.tool === "write"
                     ? text.value ?? ""
                     : applyEdit(oldText, input.args.oldString ?? input.args.old_string, text.value ?? "", input.args.replaceAll);
-                if (Buffer.byteLength(newText, "utf8") > maxTextBytes)
-                    throw new Error("new text exceeds scan limit");
-                const findings = await scan({ file: text.file, oldText, newText });
-                const block = findings.filter((finding) => finding.severity === "block");
-                if (block.length > 0) {
-                    const first = block[0];
-                    throw new Error(`LIT_HUMANIZER_BLOCKED rule=${first.rule} line=${first.line} path=${displayPath(text.file)}. Revise the new text before saving.`);
-                }
-                if (findings.length > 0) {
+                const warned = await scanTarget(text.file, oldText, newText);
+                if (warned > 0) {
                     remember(pending, input.callID, {
                         tier: "warn",
-                        message: `LIT_HUMANIZER_WARN findings=${findings.length} path=${displayPath(text.file)}. Review the new wording; keep any accurate, useful warning.`
+                        message: `LIT_HUMANIZER_WARN findings=${warned} path=${displayPath(text.file)}. Review the new wording; keep any accurate, useful warning.`
                     });
                 }
             }

package/dist/server.js

@@ -1,6 +1,5 @@
-import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { createChatMessageActivationHook, showActivationToast, showJevSkillHintToast } from "./activation.js";
+import { createChatMessageActivationHook, showActivationToast } from "./activation.js";
 import { registerLitOpenCodeAgents } from "./agents.js";
 import { createAutoHandoff } from "./auto-handoff-hooks.js";
 import { createBoundedAuthorityEventHook } from "./bounded-authority-hooks.js";
@@ -9,7 +8,6 @@ import { loadConfig } from "./config.js";
 import { createDeliverableHedgeGuard } from "./deliverable-hedge-guard.js";
 import { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.js";
 import { createLogger } from "./logger.js";
-import { createJevSkillHint } from "./jev-skill-hint.js";
 import { createIgnitionState } from "./ignition.js";
 import { createSessionLookup } from "./session-lineage.js";
 import { applyCompactionRuleReset, applyStaticRuleInjection } from "./rules/hooks.js";
@@ -62,12 +60,7 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
             ignitionState.activate(sessionID, skillId, !appendedLit);
         };
         const boundedAuthorityEvent = createBoundedAuthorityEventHook(root, input?.client, loaded.config.boundedAuthority);
-        const skillHint = createJevSkillHint({
-            traceFile: path.join(loaded.paths.logsDir, "jev-skill-hint.jsonl"),
-            traceRoot: loaded.paths.projectRoot
-        });
         // Keyed by session: the host resolves command parts into a new array before chat.message runs.
-        const pendingCommand = new Set();
         const trustedCommandActivations = new Map();
         const commandActivation = createCommandActivationHook(root, {
             commandAliasRoot: defaultOpenCodeConfigRoot(),
@@ -83,8 +76,6 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
             event: async (eventInput) => {
                 if (eventInput.event.type === "session.deleted") {
                     ignitionState.clear(eventInput.event.properties.info.id);
-                    skillHint.forget(eventInput.event.properties.info.id);
-                    pendingCommand.delete(eventInput.event.properties.info.id);
                     trustedCommandActivations.delete(eventInput.event.properties.info.id);
                 }
                 await boundedAuthorityEvent(eventInput);
@@ -100,12 +91,6 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
                     ignitionState.resetDiscipline(sessionID);
                 },
                 onSkillActivation: recordSkillActivation,
-                isCommandTurn: (sessionID) => pendingCommand.delete(sessionID),
-                skillHint: async (sessionID, promptText) => {
-                    const hint = await skillHint.hintFor(sessionID, promptText);
-                    showJevSkillHintToast(input?.client, hint, skillHint.claimAwareness(sessionID, promptText));
-                    return hint;
-                },
                 trustedInjectedSkill: (sessionID) => {
                     const skillId = trustedCommandActivations.get(sessionID);
                     trustedCommandActivations.delete(sessionID);
@@ -116,7 +101,6 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
                 }
             }),
             "command.execute.before": async (commandInput, commandOutput) => {
-                pendingCommand.add(commandInput.sessionID);
                 const priorLength = commandOutput.parts.length;
                 await commandActivation(commandInput, commandOutput);
                 const activationPart = commandOutput.parts.slice(priorLength).reverse().find((part) => trustedCommandSkillId(part) !== undefined);

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.25"><title>release: 1.0.25</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.25</text></g></svg>
+<svg xmlns="http://www.w3.org/2000/svg" width="146" height="20" role="img" aria-label="release: 1.0.27"><title>release: 1.0.27</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.27</text></g></svg>

package/docs/privacy.md

@@ -14,7 +14,7 @@ providers, npm, and other tools have their own behavior and policies.
 | Project `.litopencode/litgoal/lit-loop/` | Goals, criteria, checkpoints, session identifiers, evidence references, a brief, ledger events, and bounded lifecycle state used to resume work. Evidence files can contain commands, output, or project material. |
 | Project `.litopencode/knowledge/` | Locally captured knowledge claims and review state. Legacy skill-learning files from earlier releases are left untouched and are no longer read. |
 | Project `.litopencode/logs/litopencode.log` | The logger's JSON-lines destination for timestamps, levels, and messages when explicitly enabled. The current server creates the logger with logging disabled by default. |
-| Project `.litopencode/logs/jev-skill-hint.jsonl` | Written only when `LITOPENCODE_JEV_TRACE=1`: one record per Jev skill hint request with time, prompt SHA-256, chosen skill id, confidence, latency, HTTP status and fallback reason. No prompt text, key or response body. |
+| Project `.litopencode/logs/jev-skill-hint.jsonl` | No longer written. Earlier releases could leave this debug trace of the removed Jev skill hint; LitOpenCode never reads it, and you can delete it. |
 | OpenCode config root | Plugin registration, `litopencode.json` routes and choices, and installed command/skill files. The default is `~/.config/opencode`; `XDG_CONFIG_HOME` or a CLI `--root` changes the applicable root. |
 | Home `~/.litopencode/` | Update cache, locks, transaction journal and receipt, and retained recovery backups after an unsuccessful automatic update. Backups can contain OpenCode configuration and installed command/skill content. |
 
@@ -51,17 +51,6 @@ path and query string and normal network metadata. Never put secrets in a URL:
 redacting a returned result cannot retract a request already sent to its server.
 Retrieved text and source addresses can become part of tool output and host context.
 
-**Jev skill hint (off by default).** When `LITOPENCODE_JEV=1` and `TYPESAFE_API_KEY`
-are both set, the `chat.message` hook sends each eligible user prompt to TypeSafe at
-`api.typesafe.ai`, together with the LitOpenCode skill ids and summaries. The prompt is cut
-to 2,000 characters and home paths, e-mail addresses and token-shaped strings are replaced
-first. Anything in the prompt without a token shape is sent as written, for example hostnames,
-customer names, or a password that is not written as `password=...`. Files, tool output and
-earlier turns are not sent. Because `TYPESAFE_API_KEY` is exported in the shell that starts
-OpenCode, the agent's own tools can read it; use a key made only for this feature, with a low
-spending limit. TypeSafe's own retention and billing terms apply. Unset `LITOPENCODE_JEV` to
-stop these requests.
-
 **OpenCode and providers.** Agent prompts, user requests, selected files, and tool
 results are processed through the OpenCode host and configured provider. LitOpenCode
 does not establish their retention or training policy. Review the provider and

package/docs/reference-Ko-KR.md

@@ -439,53 +439,15 @@ OpenCode는 세션이 바쁜 동안 들어온 `summarize` 호출을 줄 세웠
   update barrier가 동작합니다. `--no-auto-update` 또는 `LITOPENCODE_NO_AUTO_UPDATE=1`로
   끌 수 있습니다. cache-only 알림은 `NO_UPDATE_NOTIFIER=1` 또는
   `LITOPENCODE_NO_UPDATE_CHECK=1`로 끌 수 있습니다.
+- 시작할 때 설치된 업데이트는 OpenCode를 다음에 시작할 때 적용됩니다. 업데이트를 실행한
+  프로세스는 이전 플러그인으로 계속 동작합니다. 실패한 업데이트가 깨끗하게 되돌려졌다면
+  시작 시에는 같은 버전을 하루 동안 다시 시도하지 않습니다(직접 실행한 `install`은 진행합니다).
+  시작할 때마다 `~/.litopencode/auto-update-check.json`에 시각, 실행 중인 버전, 결과를 남깁니다.
+  `doctor`는 이 기록과 receipt를 읽어 `autoUpdate.state`, `cause`, `nextStart`, 원인별 조치 표를
+  보여 줍니다. 실행 중인 OpenCode 내부는 볼 수 없으므로 새 버전을 확실히 쓰려면 다시 시작하세요.
 - Public-source retrieval에는 SSRF 검사, redirect 검증, byte 제한, access verdict가
   있습니다. 가져온 본문은 명령이 아니라 데이터로 처리합니다.
 
-## Jev 스킬 힌트 (선택)
-
-`chat.message` hook이 TypeSafe의 판단 모델 Jev에게 사용자 턴에 맞는 runtime 스킬을 물을 수
-있습니다. `LITOPENCODE_JEV=1`과 `TYPESAFE_API_KEY`가 모두 프로세스 환경에 있어야 켜지고, 그렇지
-않으면 네트워크 요청을 하지 않습니다. 키는 환경 변수에서만 읽고 `Authorization` header로만
-보내며, 파일·로그·화면에 남기지 않습니다.
-
-- **대상 턴.** 루트 세션만 해당합니다. 슬래시 명령(`command.execute.before`가 펼친 명령 포함),
-  lit 경로가 이미 처리한 턴, 첨부 파일 본문 같은 synthetic part, 공백을 뺀 4자 미만의
-  프롬프트는 건너뜁니다. OpenCode는 `command.execute.before`가 받은 parts 배열이 아니라 새 배열을
-  `chat.message`에 넘기므로, 명령은 세션에 표시를 남기고 그 세션의 다음 `chat.message`가 이
-  표시를 소비합니다.
-- **요청.** 조건에 맞는 턴마다 `POST https://api.typesafe.ai/v1/systemone`을 한 번 보내고
-  다시 시도하지 않으며 리다이렉트도 따르지 않습니다(`redirect: "error"`). 본문에는 `model`,
-  `state`, `questions`만 들어갑니다. `state`는 프롬프트 앞 8,000자에서 홈 경로를 `~`로, 이메일을
-  `[email]`로, 토큰 형태의 문자열(`password=`/`token=`/`secret=` 형식의 대입과 키 자체 포함)을
-  `[secret]`으로 바꾼 뒤 2,000자에서 자릅니다. 잘린 자리에 토큰 문자 8개 이상이 남으면 그것도
-  `[secret]`이 됩니다. 호스트 이름이나 고객 이름처럼 토큰 형태가 아닌 내용은 그대로 전송됩니다.
-  후보 목록은 runtime 스킬과 `none`입니다.
-- **붙는 문장.** 힌트와 실패 안내는 `synthetic` text part로 붙습니다. OpenCode는 이 part를
-  모델에 그대로 보내지만, 사용자가 쓴 글로 표시하거나 복사하지 않습니다.
-- **응답.** HTTP 200, 올바른 JSON, 후보 id와 정확히 같은 `answers.which.choice`, 기준 이상의
-  `answers.which.confidence`를 모두 만족할 때만 힌트를 붙입니다. 붙는 문장은 LitOpenCode가 정한
-  고정 문장이며 응답 본문을 옮기지 않습니다.
-- **실패 시.** 시간 초과, 네트워크 오류, 200이 아닌 상태, 잘못된 응답, 호출 한도 도달 때는 힌트
-  없이 평소대로 진행합니다. 세션의 첫 실패에만 짧은 안내 한 줄이 붙습니다.
-- **상태.** `litopencode doctor`의 `jevSkillHint` 값이 `Jev skill hint: off`, `on`,
-  `flag on but TYPESAFE_API_KEY missing` 가운데 하나로 나옵니다.
-- **화면 표시.** 세션에서 조건에 맞는 첫 턴에는 `warning` 알림에 `✦ Jev skill hint is ON`이
-  뜹니다. 그 턴에 힌트도 붙으면 이 안내가 알림의 제목이 되고 `Jev → <skill> (<seconds>s)`가
-  본문이 됩니다. TUI가 알림을 한 번에 하나만 유지하기 때문입니다. 이후 힌트가 붙는 턴에는
-  `Jev → <skill> (<seconds>s)`만 담은 `info` 알림이 뜹니다. 실패 안내, `none` 응답, 건너뛴 턴에는
-  아무것도 뜨지 않습니다. 두 알림 모두 OpenCode의 기본 표시 시간을 씁니다.
-
-| 변수 | 기본값 | 효과 |
-| --- | --- | --- |
-| `LITOPENCODE_JEV` | 없음 | `1`이면 키가 있을 때 힌트를 켭니다. |
-| `TYPESAFE_API_KEY` | 없음 | 본인의 TypeSafe 키입니다. 요금은 입력 토큰 100만 개당 약 0.04달러입니다. |
-| `LITOPENCODE_JEV_MODEL` | `jev-1.13.0` | 요청에 담는 모델 이름입니다. |
-| `LITOPENCODE_JEV_TIMEOUT_MS` | `1500` | 제한 시간(ms)이며 최대 `3000`입니다. |
-| `LITOPENCODE_JEV_MAX_CALLS` | `200` | 세션당 요청 수 한도입니다. |
-| `LITOPENCODE_JEV_MIN_CONFIDENCE` | `0.35` | 힌트를 붙이는 최소 확신도입니다. |
-| `LITOPENCODE_JEV_TRACE` | 없음 | `1`이면 요청마다 `.litopencode/logs/jev-skill-hint.jsonl`에 시각, 프롬프트 SHA-256, 고른 id, 확신도, 지연 시간, HTTP 상태, 실패 사유를 한 줄씩 남깁니다. 프롬프트 본문, 키, 응답 본문은 남기지 않습니다. |
-
 ## 패키지 경로
 
 - 패키지와 plugin id: `litopencode`

package/docs/reference.md

@@ -562,6 +562,12 @@ The route writes `.litopencode/auto-handoff.json` (the switch and the percent).
   install. Disable it with `--no-auto-update` or
   `LITOPENCODE_NO_AUTO_UPDATE=1`. The cache-only notice can also be disabled with
   `NO_UPDATE_NOTIFIER=1` or `LITOPENCODE_NO_UPDATE_CHECK=1`.
+- An update made at startup takes effect the next time OpenCode starts; the process that ran it
+  keeps the old plugin. After a failed update that was undone cleanly, startup leaves that same
+  version alone for a day (an explicit `install` still runs it). Each start writes
+  `~/.litopencode/auto-update-check.json` (time, running version, outcome). `doctor` reads it with
+  the receipt and reports `autoUpdate.state`, `cause`, `nextStart` and a cause-to-remedy table. It
+  cannot see inside a running OpenCode, so a restart is the sure way to load a new version.
 - Public-source retrieval uses SSRF checks, redirect validation, byte limits, and access
   verdicts. Fetched text is treated as data, not as instructions.
 
@@ -572,54 +578,6 @@ The route writes `.litopencode/auto-handoff.json` (the switch and the percent).
   Metadata-only overflow emits a bounded digest/omission rule fragment.
 - session-scoped rule delivery deduplicates matching content and stays bounded after compaction.
 
-## Jev skill hint (optional)
-
-The `chat.message` hook can ask Jev, TypeSafe's hosted typed-decision model, which runtime skill
-fits a user turn. It is off unless `LITOPENCODE_JEV=1` and `TYPESAFE_API_KEY` are both set in the
-process environment; otherwise it makes no network call. The key is read from the environment
-only. It is sent only in the `Authorization` header and is never written, logged or shown.
-
-- **Eligible turns.** Root sessions only. Slash commands (including every command expanded by
-  `command.execute.before`), turns a deterministic lit route already claimed, synthetic parts
-  such as attached file text, and prompts under four non-space characters are skipped. OpenCode
-  hands `chat.message` a new parts array rather than the one `command.execute.before` saw, so a
-  command marks its session instead, and that session's next `chat.message` consumes the mark.
-- **Request.** One `POST https://api.typesafe.ai/v1/systemone` per eligible turn, no retry and no
-  redirects (`redirect: "error"`). The body holds only `model`, `state` and `questions`. `state`
-  is built from the first 8,000 characters of the user's prompt text: home paths become `~`,
-  e-mail addresses `[email]`, and token-shaped strings (provider key prefixes, JWTs, PEM blocks,
-  `password=`/`token=`/`secret=`-style assignments, runs of 32 or more hex or base64
-  characters, and the key itself) `[secret]`. Only then is it cut to 2,000 characters, and a
-  run of eight or more token characters left at the cut also becomes `[secret]`. Anything
-  without a token shape, such as a hostname or a customer name, is sent as written. The catalog
-  is the Runtime Skills list above, each with its summary cut to 300 characters, plus `none`.
-- **Added text.** The hint or the fallback note is a `synthetic` text part: OpenCode still sends
-  it to the model, but does not show or copy it as the user's own words.
-- **Answer.** A hint is added only for HTTP 200, parseable JSON, an `answers.which.choice` that is
-  exactly a catalog id, and an `answers.which.confidence` at or above the threshold. The added text is
-  LitOpenCode's own fixed sentence with that id; no response text is copied into the turn.
-- **Fallback.** On a timeout, network error, non-200 status, invalid answer or reached cap, the
-  turn continues as it would without the hint. The first failure in a session adds one short
-  `LitOpenCode skill hint unavailable (<reason>); continuing normally.` line; later failures are
-  silent.
-- **Status.** `litopencode doctor` reports `jevSkillHint` as `Jev skill hint: off`, `on`, or
-  `flag on but TYPESAFE_API_KEY missing`.
-- **On screen.** On the first eligible turn of a session, a `warning` toast reads
-  `✦ Jev skill hint is ON`. When that turn also gets a hint, the notice becomes the toast's title
-  and `Jev → <skill> (<seconds>s)` its message, because the TUI keeps one toast at a time. Later
-  hinted turns show an `info` toast with only `Jev → <skill> (<seconds>s)`. Fallback notes, `none`
-  answers and skipped turns show nothing. Both toasts use OpenCode's default duration.
-
-| Variable | Default | Effect |
-| --- | --- | --- |
-| `LITOPENCODE_JEV` | unset | `1` turns the hint on when the key is also set. |
-| `TYPESAFE_API_KEY` | unset | Your own TypeSafe key. TypeSafe bills about $0.04 per million input tokens. |
-| `LITOPENCODE_JEV_MODEL` | `jev-1.13.0` | Model name sent with each request. |
-| `LITOPENCODE_JEV_TIMEOUT_MS` | `1500` | Hard timeout in milliseconds, capped at `3000`. |
-| `LITOPENCODE_JEV_MAX_CALLS` | `200` | Requests allowed per session. |
-| `LITOPENCODE_JEV_MIN_CONFIDENCE` | `0.35` | Lowest confidence that produces a hint. |
-| `LITOPENCODE_JEV_TRACE` | unset | `1` appends one record per request to `.litopencode/logs/jev-skill-hint.jsonl`: time, prompt SHA-256, chosen id, confidence, latency, HTTP status and fallback reason. It holds no prompt text, key or response body. |
-
 ## Package surface
 
 - Package and plugin id: `litopencode`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litfamily/litopencode",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "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-docx/SKILL.md

@@ -29,7 +29,7 @@ Read the user's sources and document purpose. Preserve quotations, citations, nu
 
 For a bare `lit` request without facts, choose one realistic concrete example and deliver a complete document without asking. Label invented names, dates, and numbers as sample or assumption: the frontmatter `notice:` line prints the sample-data notice once (cover or first page), and the reply repeats it. Never leave bracketed placeholders or imply that example figures were verified. An explicit non-lit request may ask for clarification about content; the look is decided by the direction step, not by a question.
 
-A `lit` report request produces `.docx` by default. Do not ask a format, font, tonality or profile question when the direction step can decide. An explicit Elsevier, ACS, IEEE, Nature or Korean publisher profile, a named tonality, or a custom template wins. Only deliver Markdown/HTML alone if requested. Keep `draft.md` next to `draft.docx`; the Markdown is an editable source, not proof the DOCX rendered correctly.
+A `lit` report request produces `.docx` by default. Do not ask a format, font, tonality or profile question when the direction step can decide. An explicit Elsevier, ACS, IEEE, Nature or Korean publisher profile, a named tonality, or a custom template wins. Only deliver Markdown/HTML alone if requested. A requested Markdown or plain-text deliverable (`report.md`, "in Markdown", "as plain text") is a finished document for a reader, not this skill's source: write it as ordinary Markdown with headings, paragraphs, lists and tables, no frontmatter, no `:::` directive blocks and no tonality keys, and do not build a `.docx` beside it unless one was asked for. The frontmatter and component dialect below belong only to a source this skill converts to `.docx` or PDF, or to a source the user explicitly asked for. Keep `draft.md` next to `draft.docx`; the Markdown is an editable source, not proof the DOCX rendered correctly.
 
 ## #contract.mode_matrix
 

package/skills/lit-humanizer/SKILL.md

@@ -115,7 +115,7 @@ DOCX and PPTX text extraction uses `scripts/extract_office_text.py`, which relie
 
 ## Guard scope and limits
 
-Scan only text being added or changed. Preserve pre-existing file content and user quotations. Skip fenced and inline code, Markdown blockquotes, and internal paths such as `plans/`, `evidence/`, `HANDOFF*`, `.lit*/`, `.hermes/`, and ledgers. The native OpenCode guard applies to reader-facing text paths, not every source or configuration file. Office and PDF checks happen after creation: a hit asks the model to fix its source and rebuild; it cannot undo the tool that created the file.
+Scan only text being added or changed. Preserve pre-existing file content and user quotations. Skip fenced and inline code, Markdown blockquotes (except a quote opening with a bold label, which the pledge rules read as the author's callout), and internal paths such as `plans/`, `evidence/`, `HANDOFF*`, `.lit*/`, `.hermes/`, and ledgers. The native OpenCode guard applies to reader-facing text paths, not every source or configuration file. Office and PDF checks happen after creation: a hit asks the model to fix its source and rebuild; it cannot undo the tool that created the file.
 
 Block only high-confidence patterns such as label-only evidence lines, stacked disclaimers, and chatbot residue. Word choice, contrast, triads, and rhythm are warnings. A hit is an editing signal, not proof of model authorship. Stop when another change would alter meaning, hide a real limitation, or flatten the writer's voice.
 

package/skills/lit-humanizer/references/taxonomy.md

@@ -17,9 +17,9 @@ This original category comes from the 26 real lines in fixtures/pos-real.txt and
 - ko-bracket-status-tag and en-bracket-status-tag — ko/en, block. Replace bracket keys with a sentence describing the status.
 - ko-standalone-scope-disclaimer and en-standalone-scope-disclaimer — ko/en, block for stock disclaimers. Preserve a user-requested legal, medical or safety notice and place it once where it applies.
 - ko-status-negation, ko-mi-status, en-epistemic-negation and en-not-performed — warnings. ko-status-negation also reads 쓰지 않음, the polite 않습니다/않았습니다 endings and a bold-wrapped ending, so a method line such as “fitting parameter는 쓰지 않음” is advised on, never refused. A negative result or unperformed action may be the finding. Write the actor, scope and verb plainly; never turn unknown into false or an estimate into a fact.
-- ko-negative-pledge — ko, block, one line at a time. The reader meets a sentence about what the document is not for: a self-reference (이 표, 본 자료, 해당 보고서) whose verb is negated 해석/의미/주장/대표 or whose noun is a claim noun with 아님; a bare “비교로 쓰지 않음” with no subject; or a purpose word such as 공개용 수치가 아님. Move the sentence to the reply, or turn it into a fact about the data beside the number it affects (“샘플은 한 공정 조건만 포함한다”). Operating rules (사용하지 않습니다, 냉각수로 쓰지 않음), data-handling rules, and legal or financial notices (대체하지, 보장하지, 권유가 아닙니다) stay outside the pattern on purpose.
+- ko-negative-pledge — ko, block, one line at a time. The reader meets a sentence about what the document is not for: a self-reference (이 표, 본 자료, 해당 보고서) whose verb is negated 해석/의미/주장/대표 or whose noun is a claim noun with 아님; a bare “비교로 쓰지 않음” with no subject; a purpose word such as 공개용 수치가 아님; a comparison refusal about the numbers (숫자는 서로 비교할 수 없습니다 when it stands alone, 순위처럼 읽지 말아 주세요); or a ranking refusal (…만으로 순위를 정할 수 없다, 표의 순서는 순위가 아님). Move the sentence to the reply, or turn it into a fact about the data beside the number it affects (“샘플은 한 공정 조건만 포함한다”). Operating rules (사용하지 않습니다, 냉각수로 쓰지 않음), conditional method facts (합계와 비교하면 안 됩니다), type rules (숫자와 문자열은 서로 비교할 수 없습니다), data-handling rules, and legal or financial notices (대체하지, 보장하지, 권유가 아닙니다) stay outside the pattern on purpose. A quote line that opens with a bold label (`> **주의:** …`) is the author's own callout, so this rule and the two below read it with the quote marker blanked; a plain quote line stays skipped.
 - ko-negative-pledge-repeat — ko, block, whole document. Two or more sentences ending in 해석하지/주장하지/대표하지 않음, or in a claim noun + 아님, make a list of disclaimers. One such sentence stays with the warning above; the use verbs and 의미하/간주하/인용하 are left out because definitions and processing rules end that way.
-- en-negative-pledge — en, block, one sentence. “This is not intended as a benchmark”, “these figures do not constitute a comparison”, “not to be read as a ranking”, and “the deck makes no claim about …” say what the document is not. A comparison, benchmark or ranking noun is required, and substitute-for-advice and investment, legal or medical advice notices stay clean. Say it in the reply, or state the data fact.
+- en-negative-pledge — en, block, one sentence. “This is not intended as a benchmark”, “these figures do not constitute a comparison”, “not to be read as a ranking”, and “the deck makes no claim about …” say what the document is not. A comparison, benchmark or ranking noun is required, and substitute-for-advice and investment, legal or medical advice notices stay clean. A deliverable subject (this table, our deck) that is not a ranking or is not meant to rank also counts, and so do “they are not a ranking.” and “do not compare these numbers.” at the end of a sentence; a refusal that goes on to describe or instruct stays clean. It reads bold-label callouts too. Say it in the reply, or state the data fact.
 - ko-plain-meta-label-warn and en-plain-caveat-label — warnings for boundary headings. They may be useful in internal or technical packets.
 - en-knowledge-cutoff, en-ai-self-disclaimer, en-hope-helps and ko-chatbot-signoff — block. Remove the model wrapper or generic sign-off, then retain the answer.
 - ko-chatbot-opener and en-chatbot-opener — block stock greetings and praise at the start of a deliverable.