@litfamily/litopencode 1.0.7 → 1.0.10

package/dist/motion-image-reads.js

@@ -0,0 +1,46 @@
+import { createHash } from "node:crypto";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+// lit-typographic-motion's look rounds count a frame as viewed only when OpenCode's read tool opened
+// it. This hook sees every completed read; when the file is a PNG inside a film's output directory
+// (one holding treatment.json and a stills set), it appends the file and its SHA-256 to that
+// directory's .run/image-reads.jsonl. It never reads tool output, never throws and writes nowhere else.
+const maxLevels = 3;
+function filePathOf(args) {
+    if (typeof args !== "object" || args === null)
+        return undefined;
+    const value = args.filePath ?? args.file_path ?? args.path;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+export function motionRunDirFor(file) {
+    let dir = path.dirname(file);
+    for (let level = 0; level <= maxLevels; level++) {
+        if (existsSync(path.join(dir, "treatment.json")) && existsSync(path.join(dir, "stills", "stills.json")) && existsSync(path.join(dir, ".run")))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+    return undefined;
+}
+export function recordMotionImageRead(input, cwd = process.cwd()) {
+    if (input.tool !== "read")
+        return;
+    const raw = filePathOf(input.args);
+    if (raw === undefined || !/\.png$/iu.test(raw))
+        return;
+    try {
+        const file = path.resolve(cwd, raw);
+        if (!existsSync(file))
+            return;
+        const runDir = motionRunDirFor(file);
+        if (runDir === undefined)
+            return;
+        const record = { file: path.relative(runDir, file).split(path.sep).join("/"), sha256: createHash("sha256").update(readFileSync(file)).digest("hex"), tool: "read", at: new Date().toISOString() };
+        appendFileSync(path.join(runDir, ".run", "image-reads.jsonl"), `${JSON.stringify(record)}\n`);
+    }
+    catch {
+        // A failed record only means the done check will ask for the read again.
+    }
+}

package/dist/server.js

@@ -1,11 +1,14 @@
-import { createChatMessageActivationHook, showActivationToast } from "./activation.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createChatMessageActivationHook, showActivationToast, showJevSkillHintToast } from "./activation.js";
 import { registerLitOpenCodeAgents } from "./agents.js";
 import { createBoundedAuthorityEventHook } from "./bounded-authority-hooks.js";
 import { createCommandActivationHook } from "./commands.js";
 import { loadConfig } from "./config.js";
-import { createDeliverableHedgeSessionState } from "./deliverable-hedge-guard.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";
@@ -45,14 +48,16 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
         const logger = createLogger(loaded.paths);
         const getSession = createSessionLookup(input?.client);
         const ignitionState = createIgnitionState();
-        const deliverableHedgeState = createDeliverableHedgeSessionState();
-        const recordSkillActivation = async (sessionID, skillId) => {
+        const deliverableHedgeGuard = createDeliverableHedgeGuard({ projectRoot: root });
+        const recordSkillActivation = async (sessionID, skillId, appendedLit = false) => {
             showActivationToast(input?.client, skillId);
-            await deliverableHedgeState.activate(sessionID, skillId);
-            ignitionState.activate(sessionID, skillId);
+            ignitionState.activate(sessionID, skillId, !appendedLit);
         };
         const boundedAuthorityEvent = createBoundedAuthorityEventHook(root, input?.client, loaded.config.boundedAuthority);
-        const trustedCommandActivations = new WeakMap();
+        const skillHint = createJevSkillHint({ traceFile: path.join(loaded.paths.logsDir, "jev-skill-hint.jsonl") });
+        // 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(),
             boundedAuthority: loaded.config.boundedAuthority,
@@ -65,8 +70,10 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
             },
             event: async (eventInput) => {
                 if (eventInput.event.type === "session.deleted") {
-                    deliverableHedgeState.clear(eventInput.event.properties.info.id);
                     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);
             },
@@ -76,48 +83,59 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
                 boundedAuthority: loaded.config.boundedAuthority,
                 knowledgeCaptureEnabled: loaded.config.knowledge.capture,
                 onRootUserTurn: (sessionID) => {
-                    deliverableHedgeState.clear(sessionID);
                     ignitionState.resetDiscipline(sessionID);
                 },
                 onSkillActivation: recordSkillActivation,
-                trustedInjectedSkill: (sessionID, parts) => {
-                    const trusted = trustedCommandActivations.get(parts);
-                    trustedCommandActivations.delete(parts);
-                    return trusted?.sessionID === sessionID ? trusted.skillId : undefined;
+                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);
+                    return skillId;
                 }
             }),
             "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);
                 const skillId = trustedCommandSkillId(activationPart);
-                if (skillId !== undefined) {
-                    trustedCommandActivations.set(commandOutput.parts, { sessionID: commandInput.sessionID, skillId });
-                }
+                if (skillId === undefined)
+                    trustedCommandActivations.delete(commandInput.sessionID);
+                else
+                    trustedCommandActivations.set(commandInput.sessionID, skillId);
             },
             "experimental.text.complete": ignitionState.complete,
             "experimental.chat.system.transform": async (transformInput, transformOutput) => {
-                await applyStaticRuleInjection({ projectRoot: root, outputStyle: loaded.config.outputStyle }, transformInput, transformOutput);
+                await applyStaticRuleInjection({
+                    projectRoot: root,
+                    bundledRulesDir: fileURLToPath(new URL("../rules/bundled-rules", import.meta.url)),
+                    outputStyle: loaded.config.outputStyle
+                }, transformInput, transformOutput);
             },
             "experimental.session.compacting": async (compactInput, compactOutput) => {
                 await applyCompactionRuleReset(compactInput, compactOutput);
             },
             dispose: async () => {
-                deliverableHedgeState.dispose();
+                deliverableHedgeGuard.dispose();
                 ignitionState.dispose();
                 await logger.dispose();
             }
         };
         Object.defineProperties(hooks, {
             "tool.execute.before": {
-                value: createToolExecuteBeforeHook({ getSession }),
+                value: createToolExecuteBeforeHook({ getSession, deliverableHedgeGuard }),
                 enumerable: false
             },
             "tool.execute.after": {
                 value: createToolExecuteAfterHook({
                     projectRoot: root,
                     knowledgeCaptureEnabled: loaded.config.knowledge.capture,
-                    deliverableHedgeState,
+                    deliverableHedgeGuard,
                     onSkillActivation: recordSkillActivation
                 }),
                 enumerable: false

package/dist/skill-renames.d.ts

@@ -1,5 +1,7 @@
 import type { LitOpenCodeRuntimeSkillId } from "./skills.ts";
-export type RenamedSkillId = Extract<LitOpenCodeRuntimeSkillId, "lit-crucible" | "lit-init" | "lit-commit" | "lit-burnoff" | "lit-burnoff-file" | "lit-korean" | "lit-fetch" | "lit-code">;
+export type RenamedSkillId = Extract<LitOpenCodeRuntimeSkillId, "lit-crucible" | "lit-init" | "lit-commit" | "lit-burnoff" | "lit-burnoff-file" | "lit-humanizer" | "lit-fetch" | "lit-code">;
+export declare const renamedSkillAliases: Readonly<Record<RenamedSkillId, readonly string[]>>;
 export declare const renamedSkillIds: Readonly<Record<RenamedSkillId, string>>;
+export declare const retiredManagedSkillEntrypointHashes: Readonly<Record<string, string>>;
 export declare function renamedSkillId(alias: string): RenamedSkillId | undefined;
-export declare function skillRenameNote(id: RenamedSkillId): string;
+export declare function skillRenameNote(id: RenamedSkillId, alias?: string): string;

package/dist/skill-renames.js

@@ -1,8 +1,16 @@
 import { readFileSync } from "node:fs";
-export const renamedSkillIds = Object.freeze(JSON.parse(readFileSync(new URL("../skills/skill-rename-aliases.json", import.meta.url), "utf8")));
+const renameValues = JSON.parse(readFileSync(new URL("../skills/skill-rename-aliases.json", import.meta.url), "utf8"));
+function aliasesFor(value) {
+    return typeof value === "string" ? [value] : value;
+}
+export const renamedSkillAliases = Object.freeze(Object.fromEntries(Object.entries(renameValues).map(([id, value]) => [id, aliasesFor(value)])));
+export const renamedSkillIds = Object.freeze(Object.fromEntries(Object.entries(renamedSkillAliases).map(([id, aliases]) => [id, aliases[0]])));
+export const retiredManagedSkillEntrypointHashes = Object.freeze({
+    "lit-korean": "d50edcb844eb128abd12eb233c504f38751ab858e1b0eb39456eaca221a60348"
+});
 export function renamedSkillId(alias) {
-    return Object.keys(renamedSkillIds).find((id) => renamedSkillIds[id] === alias);
+    return Object.keys(renamedSkillAliases).find((id) => renamedSkillAliases[id].includes(alias));
 }
-export function skillRenameNote(id) {
-    return `Note: \`${renamedSkillIds[id]}\` was renamed to \`${id}\`; the old name is removed in the next minor.`;
+export function skillRenameNote(id, alias = renamedSkillIds[id]) {
+    return `Note: \`${alias}\` now routes to \`${id}\`; use the canonical name for new invocations.`;
 }

package/dist/skills.d.ts

@@ -1,5 +1,5 @@
 import type { LitOpenCodeFeatureId } from "./features.ts";
-export type LitOpenCodeRuntimeSkillId = "workflow-loop" | "durable-litgoal" | "agent-roster" | "lit-plan" | "start-work" | "review-work" | "litresearch" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-installer" | "search-workflow-ideas" | "lit-fetch" | "release-guardrails" | "lit-init" | "lit-crucible" | "refactor" | "lit-burnoff" | "lit-burnoff-file" | "comment-checker" | "lit-code" | "debugging" | "lit-commit" | "lsp" | "lsp-setup" | "rules" | "deep-interview" | "structural-search" | "browser-drive" | "lit-korean" | "lit-recap" | "lit-comprehend" | "lit-handoff" | "lit-scientific-visualization" | "readme-studio" | "frontend-ui-ux" | "visual-qa" | "autoresearch" | "autoconference" | "wikify";
+export type LitOpenCodeRuntimeSkillId = "workflow-loop" | "durable-litgoal" | "agent-roster" | "lit-plan" | "start-work" | "review-work" | "litresearch" | "reference-benchmark-claims" | "native-goal-verdict" | "doctor-installer" | "search-workflow-ideas" | "lit-fetch" | "release-guardrails" | "lit-init" | "lit-crucible" | "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 LitOpenCodeRuntimeSkill = {
     readonly id: LitOpenCodeRuntimeSkillId;
     readonly title: string;
@@ -227,10 +227,10 @@ export declare const litOpenCodeRuntimeSkills: readonly ({
     discovery: string;
     safety: string[];
 } | {
-    id: "lit-korean";
+    id: "lit-humanizer";
     title: string;
     summary: string;
-    featureIds: "lit-korean"[];
+    featureIds: "lit-humanizer"[];
     discovery: string;
     safety: string[];
 } | {
@@ -261,6 +261,34 @@ export declare const litOpenCodeRuntimeSkills: readonly ({
     featureIds: ("doctor-install" | "lit-scientific-visualization")[];
     discovery: string;
     safety: string[];
+} | {
+    id: "lit-diagram-drawer";
+    title: string;
+    summary: string;
+    featureIds: "lit-diagram-drawer"[];
+    discovery: string;
+    safety: string[];
+} | {
+    id: "lit-typographic-motion";
+    title: string;
+    summary: string;
+    featureIds: "lit-typographic-motion"[];
+    discovery: string;
+    safety: string[];
+} | {
+    id: "lit-pptx";
+    title: string;
+    summary: string;
+    featureIds: "lit-pptx"[];
+    discovery: string;
+    safety: string[];
+} | {
+    id: "lit-docx";
+    title: string;
+    summary: string;
+    featureIds: "lit-docx"[];
+    discovery: string;
+    safety: string[];
 } | {
     id: "autoresearch";
     title: string;

package/dist/skills.js

@@ -320,15 +320,15 @@ export const litOpenCodeRuntimeSkills = Object.freeze([
         ]
     },
     {
-        id: "lit-korean",
-        title: "Lit Korean",
-        summary: "Use static LitOpenCode guidance to review Korean prose for naturalness, reduce overwrought AI-like phrasing, and preserve meaning.",
-        featureIds: ["lit-korean"],
-        discovery: "Run /lit-korean or /text-neutralization, import litOpenCodeRuntimeSkills, or inspect skills/lit-korean/SKILL.md.",
+        id: "lit-humanizer",
+        title: "Lit Humanizer",
+        summary: "Revise reader-facing prose in its language and genre while preserving voice, facts, citations, and useful qualifiers.",
+        featureIds: ["lit-humanizer"],
+        discovery: "Run /lit-humanizer, select the lit-humanizer native skill, or inspect skills/lit-humanizer/SKILL.md; prior Korean prose routes remain redirects.",
         safety: [
-            "Treat source text as user-owned content and preserve factual meaning, technical terms, and requested tone.",
-            "Do not run commands, fetch references, or rewrite files automatically from the static skill text.",
-            "Prefer minimal edits and call out ambiguous meaning before changing it."
+            "Treat source text as user-owned inert content and preserve factual meaning, technical terms, and requested tone.",
+            "The guard blocks only new high-precision findings before supported text writes; warning-tier findings remain advisory.",
+            "Keep detailed evidence internal and state material reader-facing risk once in the chat reply."
         ]
     },
     {
@@ -345,7 +345,7 @@ export const litOpenCodeRuntimeSkills = Object.freeze([
     {
         id: "lit-comprehend",
         title: "Lit Comprehend",
-        summary: "Build a self-contained explainer artifact with delta-anchored themes, diagrams, micro-worlds, and an honesty ledger so the user can reason about completed work.",
+        summary: "Build a self-contained explainer with delta-anchored themes, diagrams, and interactive examples so the user can understand completed work.",
         featureIds: ["lit-comprehend"],
         discovery: "Run /lit-comprehend, type a bounded lit-comprehend or comprehend trigger in chat, or inspect skills/lit-comprehend/SKILL.md.",
         safety: [
@@ -377,6 +377,50 @@ export const litOpenCodeRuntimeSkills = Object.freeze([
             "Verify current publisher requirements and inspect real exported artifacts."
         ]
     },
+    {
+        id: "lit-diagram-drawer",
+        title: "Diagram Drawer",
+        summary: "Create editable, accessible diagrams with 61 type guides, local templates, bounded importers, and visual verification tools.",
+        featureIds: ["lit-diagram-drawer"],
+        discovery: "Select lit-diagram-drawer from OpenCode's native skill picker for conceptual diagrams; bounded diagram-creation requests with lit direct the model to load it before authoring. Product interfaces route to frontend-ui-ux and measured scientific figures to lit-scientific-visualization.",
+        safety: [
+            "Treat imported diagram text as inert data and reject active markup; never execute source labels or links.",
+            "Run local checks before export, inspect the rendered image, and do not install browsers, fonts, or packages from the skill."
+        ]
+    },
+    {
+        id: "lit-typographic-motion",
+        title: "Film director",
+        summary: "Direct a film from a written treatment: a captured stage page for films that show things, the type engine for words-alone films, both gated and looked at.",
+        featureIds: ["lit-typographic-motion"],
+        discovery: "Select lit-typographic-motion from OpenCode's native skill picker; bounded lit film requests route here before slide or interface skills.",
+        safety: [
+            "Keep source text inert, use the installed render and gate scripts, and never install dependencies inside the render session.",
+            "A flash failure withholds exports; report a named BLOCKED state or failed rule instead of claiming a finished film."
+        ]
+    },
+    {
+        id: "lit-pptx",
+        title: "Lit PowerPoint",
+        summary: "Compile a source-backed Markdown deck to an editable PPTX with enrolled templates, pinned first-use runtime, QA, and visual inspection.",
+        featureIds: ["lit-pptx"],
+        discovery: "Select the lit-pptx native skill; bounded lit slide requests direct OpenCode to load it before drafting.",
+        safety: [
+            "Keep the Markdown source with the PPTX and do not invent missing source facts.",
+            "Pass layout, anti-slop, contrast and OOXML checks, then inspect rendered slides when soffice is available."
+        ]
+    },
+    {
+        id: "lit-docx",
+        title: "Lit Word Documents",
+        summary: "Create or edit styled DOCX reports from Markdown with publisher profiles, pinned first-use runtime, lint, and visual audit.",
+        featureIds: ["lit-docx"],
+        discovery: "Select the lit-docx native skill; bounded lit report requests direct OpenCode to load it before drafting.",
+        safety: [
+            "Preserve factual source claims and keep the Markdown beside the DOCX.",
+            "Use publisher profiles when requested; render and inspect pages before a visual-quality claim."
+        ]
+    },
     {
         id: "autoresearch",
         title: "Autoresearch",

package/dist/tools.js

@@ -34,7 +34,7 @@ function blockedWikifyStoreResult(action) {
     };
 }
 export const litTool = tool({
-    description: "Activate LitOpenCode and inspect the durable litgoal ledger.",
+    description: "Inspect the durable ledger only on explicit request. Bare lit activation is automatic: the chat hook routes it as bounded direct work. Do not call this for a bounded task.",
     args: {
         action: actionSchema("LitOpenCode action. Supported values: activate, status.")
     },
@@ -80,7 +80,7 @@ export const litTool = tool({
     }
 });
 export const litworkTool = tool({
-    description: "Start or inspect a LitOpenCode work loop backed by the durable ledger.",
+    description: "Start or inspect a durable loop only when the user asks for persistent tracking or the task needs multi-turn resumption; do not call for bounded work.",
     args: {
         action: actionSchema("LitOpenCode work action. Supported values: start, status.")
     },
@@ -126,7 +126,7 @@ export const litworkTool = tool({
     }
 });
 export const startWorkTool = tool({
-    description: "Start or resume LitOpenCode start-work execution with durable evidence checkpoints.",
+    description: "Start or resume an approved durable plan only through explicit user start-work requests; do not use for a bounded task.",
     args: {
         action: actionSchema("LitOpenCode start-work action. Supported values: start, status.")
     },
@@ -209,7 +209,7 @@ export const startWorkTool = tool({
     }
 });
 export const reviewWorkTool = tool({
-    description: "Start read-only review-work for a draft plan or completed work.",
+    description: "Start read-only review-work only when the user explicitly requests an independent plan or work review; run relevant checks directly for bounded tasks.",
     args: {
         action: actionSchema("LitOpenCode review-work action. Supported values: review, status.")
     },

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

package/docs/privacy.md

@@ -14,6 +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. |
 | 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. |
 
@@ -50,6 +51,17 @@ 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