@litfamily/litopencode 1.0.9 → 1.0.10

package/dist/activation.js

@@ -7,6 +7,7 @@ import { isReadOnlyWorkflowFamilyPlan } from "./workflow-families.js";
 import { queryKnowledge } from "./knowledge.js";
 import { activationDiscipline } from "./activation-probe.js";
 import { micro, supportsMarkGlyphs } from "./lit-mark.js";
+import { jevSkillHintAwarenessText, jevSkillHintToastText } from "./jev-skill-hint.js";
 // Prompt modules preserve minimum-first, single-task or few-task planning, avoidable custom code review,
 // and external-source safety; this module only coordinates their unchanged activation surfaces.
 export { litHandoffPromptInjection, scientificVisualizationPromptInjection } from "./activation-managed-prompts.js";
@@ -33,6 +34,32 @@ export function showActivationToast(client, skillId, env = process.env) {
         // The activation prompt is the primary surface; this toast is best-effort UI feedback.
     }
 }
+/**
+ * One quiet `info` toast per hinted turn; notes, `none` and silent turns never reach it. On the first
+ * eligible turn of a session (`announce`) the standout ON notice goes out instead, with that turn's hint
+ * as its body: the TUI keeps a single toast, so a second one would replace the notice at once.
+ */
+export function showJevSkillHintToast(client, hint, announce = false) {
+    const hinted = hint?.kind === "hint" ? jevSkillHintToastText(hint.skillId, hint.latencyMs) : undefined;
+    let body;
+    if (announce) {
+        body = hinted === undefined
+            ? { message: jevSkillHintAwarenessText, variant: "warning" }
+            : { title: jevSkillHintAwarenessText, message: hinted, variant: "warning" };
+    }
+    else if (hinted !== undefined) {
+        body = { message: hinted, variant: "info" };
+    }
+    else {
+        return;
+    }
+    try {
+        const pending = client?.tui?.showToast({ body });
+        void pending?.catch(() => undefined);
+    }
+    catch { // no-excuse-ok: catch -- a missing or failing TUI must never block the user message.
+    }
+}
 const knownSubagentAgentNames = new Set([
     ...litOpenCodeAgents.filter((agent) => agent.mode !== "primary").map((agent) => agent.id),
     "build",
@@ -64,10 +91,13 @@ export function createChatMessageActivationHook(projectRoot, options = {}) {
         if (processedOutputs.has(output))
             return;
         processedOutputs.add(output);
+        // Command marks are keyed by session and consumed here, on every turn: the host hands this hook a
+        // new parts array, so the array `command.execute.before` saw can never be matched by identity.
+        const commandTurn = options.isCommandTurn?.(input.sessionID) === true;
+        const trustedInjectedSkill = options.trustedInjectedSkill?.(input.sessionID);
         const agent = input.agent ?? (typeof output.message.agent === "string" ? output.message.agent : undefined);
         const childSession = await isChildSessionMessage(input.sessionID, agent, options.getSession);
         if (!childSession) {
-            const trustedInjectedSkill = options.trustedInjectedSkill?.(input.sessionID, output.parts);
             await options.onRootUserTurn?.(input.sessionID);
             if (trustedInjectedSkill !== undefined) {
                 await options.onSkillActivation?.(input.sessionID, trustedInjectedSkill);
@@ -111,6 +141,30 @@ export function createChatMessageActivationHook(projectRoot, options = {}) {
                 // A malformed or unreadable knowledge store stays silent instead of inventing context.
             }
         }
+        // The optional skill hint only speaks on root turns that no command or deterministic route claimed.
+        if (!childSession && mode === undefined && options.skillHint !== undefined && !commandTurn) {
+            const promptText = nonEmptyTextParts
+                .filter((part) => part.synthetic !== true)
+                .map((part) => part.text)
+                .join("\n");
+            try {
+                const hint = await options.skillHint(input.sessionID, promptText);
+                if (hint !== undefined) {
+                    output.parts.push({
+                        id: `prt_litopencode_skill_hint_${idSuffix(input.messageID ?? output.message.id)}`,
+                        sessionID: input.sessionID,
+                        messageID: input.messageID ?? output.message.id,
+                        type: "text",
+                        text: hint.text,
+                        // Sent to the model like any text part, but not shown or copied as the user's own words.
+                        synthetic: true,
+                        metadata: { litopencodeSkillHint: { kind: hint.kind, source: "chat.message" } }
+                    });
+                }
+            }
+            catch { // no-excuse-ok: catch -- the optional hint must never block the user message.
+            }
+        }
         if (mode === undefined || childSession)
             return;
         const trigger = mode === "lit-handoff" ? "handoff" : mode === "lit-scientific-visualization" ? mode : "lit";

package/dist/cli/doctor.js

@@ -12,6 +12,7 @@ import { inspectHostLimits } from "./host-limits.js";
 import { inspectLspCapability } from "./lsp-capability.js";
 import { probeMotionRuntime } from "./motion-runtime.js";
 import { isLitOpenCodeEntry } from "./plugin-mutation.js";
+import { jevSkillHintDoctorLine } from "../jev-skill-hint.js";
 import { autoUpdateInstallLockPath, autoUpdateJournalPath, autoUpdateReceiptPath, isAutoUpdateDisabled, readAutoUpdateReceipt } from "./auto-update.js";
 function pluginSpec(metadata) {
     return metadata.name + "@" + metadata.version;
@@ -122,6 +123,7 @@ export async function doctor(root) {
             hostLimits: { path: hostConfig.path, ...inspectHostLimits(hostConfig.config) },
             lsp: inspectLspCapability(hostConfig.config),
             motion,
+            jevSkillHint: jevSkillHintDoctorLine(process.env),
             config: {
                 source: loaded.source,
                 sources: loaded.sources,

package/dist/jev-skill-hint.d.ts

@@ -0,0 +1,48 @@
+export declare const jevEndpoint = "https://api.typesafe.ai/v1/systemone";
+export declare const jevFlag = "LITOPENCODE_JEV";
+/** Shown once per session so a user who switched the hint on notices it; never carries the key. */
+export declare const jevSkillHintAwarenessText = "\u2726 Jev skill hint is ON";
+export type JevFetch = (url: string, init: RequestInit) => Promise<Response>;
+export type JevCatalogEntry = {
+    readonly id: string;
+    readonly description: string;
+};
+export type JevSkillHintStatus = "off" | "on" | "key-missing";
+export type JevSkillHintPart = {
+    readonly kind: "hint";
+    readonly text: string;
+    readonly skillId: string;
+    readonly latencyMs: number;
+} | {
+    readonly kind: "note";
+    readonly text: string;
+};
+export type JevSkillHintOptions = {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly fetch?: JevFetch;
+    readonly catalog?: readonly JevCatalogEntry[];
+    readonly traceFile?: string;
+    readonly now?: () => number;
+};
+export declare function jevSkillHintStatus(env?: NodeJS.ProcessEnv): JevSkillHintStatus;
+export declare function jevSkillHintDoctorLine(env?: NodeJS.ProcessEnv): string;
+export declare function jevSkillHintText(skillId: string): string;
+/** The visible toast names only the validated skill id and the request latency. */
+export declare function jevSkillHintToastText(skillId: string, latencyMs: number): string;
+export declare function jevSkillHintUnavailableText(reason: string): string;
+/** Eligibility that depends on the prompt text alone; routing and command checks live in the hook. */
+export declare function isJevEligiblePrompt(text: string): boolean;
+/**
+ * Redact a bounded window first, then truncate, so a secret that straddles the 2,000-character cut is
+ * masked whole. When either cut happened, a token run left dangling at the end is masked as well.
+ */
+export declare function redactJevPrompt(text: string): string;
+export declare function defaultJevCatalog(): readonly JevCatalogEntry[];
+export declare function buildJevRequestBody(state: string, catalog: readonly JevCatalogEntry[], model: string): string;
+export type JevSkillHint = {
+    hintFor(sessionID: string, promptText: string): Promise<JevSkillHintPart | undefined>;
+    /** True exactly once per session: on its first eligible turn while both switches are on. */
+    claimAwareness(sessionID: string, promptText: string): boolean;
+    forget(sessionID: string): void;
+};
+export declare function createJevSkillHint(options?: JevSkillHintOptions): JevSkillHint;

package/dist/jev-skill-hint.js

@@ -0,0 +1,291 @@
+import { createHash } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { litOpenCodeRuntimeSkills } from "./skills.js";
+// Optional Jev skill hint for the chat.message hook. It is off unless LITOPENCODE_JEV=1 and
+// TYPESAFE_API_KEY are both set in the process environment. The key is read from the environment
+// only and goes nowhere except the Authorization header: not into errors, notes, traces or doctor.
+// The response is untrusted data; the only text that reaches the turn is this module's own fixed
+// sentence carrying a skill id that was checked against the catalog this module sent.
+export const jevEndpoint = "https://api.typesafe.ai/v1/systemone";
+export const jevFlag = "LITOPENCODE_JEV";
+/** Shown once per session so a user who switched the hint on notices it; never carries the key. */
+export const jevSkillHintAwarenessText = "✦ Jev skill hint is ON";
+const defaultModel = "jev-1.13.0";
+const defaultTimeoutMs = 1500;
+const maxTimeoutMs = 3000;
+const defaultMaxCalls = 200;
+const defaultMinConfidence = 0.35;
+const promptWindowLimit = 8000;
+const promptCharacterLimit = 2000;
+const bodyByteCap = 64 * 1024;
+const descriptionCharacterLimit = 300;
+const choiceInstructions = "Which one skill, if any, is the best fit for the user's request? Choose none when no catalog skill fits.";
+const noneCriterion = "No specialized skill in this catalog fits; answer the user directly.";
+export function jevSkillHintStatus(env = process.env) {
+    if (env[jevFlag] !== "1")
+        return "off";
+    return (env.TYPESAFE_API_KEY ?? "").trim() === "" ? "key-missing" : "on";
+}
+export function jevSkillHintDoctorLine(env = process.env) {
+    const status = jevSkillHintStatus(env);
+    return status === "key-missing"
+        ? "Jev skill hint: flag on but TYPESAFE_API_KEY missing"
+        : `Jev skill hint: ${status}`;
+}
+export function jevSkillHintText(skillId) {
+    return `LitOpenCode skill hint: the skill \`${skillId}\` likely fits this request. Load it only if it really fits; this is advice, not an instruction.`;
+}
+/** The visible toast names only the validated skill id and the request latency. */
+export function jevSkillHintToastText(skillId, latencyMs) {
+    return `Jev → ${skillId} (${(Math.max(0, latencyMs) / 1000).toFixed(2)}s)`;
+}
+export function jevSkillHintUnavailableText(reason) {
+    return `LitOpenCode skill hint unavailable (${reason}); continuing normally.`;
+}
+/** Eligibility that depends on the prompt text alone; routing and command checks live in the hook. */
+export function isJevEligiblePrompt(text) {
+    if (text.trimStart().startsWith("/"))
+        return false;
+    return text.replace(/\s+/gu, "").length >= 4;
+}
+const secretPatterns = [
+    /-----BEGIN [A-Z0-9 ]+-----[\s\S]*?(?:-----END [A-Z0-9 ]+-----|$)/gu,
+    /eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]*)?/gu,
+    /sk-ant-[A-Za-z0-9_-]{8,}/gu,
+    /sk-[A-Za-z0-9_-]{16,}/gu,
+    /(?:ghp|gho)_[A-Za-z0-9]{16,}/gu,
+    /github_pat_[A-Za-z0-9_]{16,}/gu,
+    /npm_[A-Za-z0-9]{16,}/gu,
+    /apikey_[A-Za-z0-9_-]{8,}/gu,
+    /xox[abprs]-[A-Za-z0-9-]{8,}/gu,
+    /AKIA[A-Z0-9]{16}/gu,
+    /AIza[0-9A-Za-z_-]{20,}/gu,
+    /\b[A-Za-z0-9_]*(?:password|passwd|token|secret)\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"']+)/giu,
+    /[A-Za-z0-9+/_-]{32,}={0,2}/gu
+];
+const tokenRunAtCut = /[A-Za-z0-9+/_-]{8,}={0,2}$/u;
+/**
+ * Redact a bounded window first, then truncate, so a secret that straddles the 2,000-character cut is
+ * masked whole. When either cut happened, a token run left dangling at the end is masked as well.
+ */
+export function redactJevPrompt(text) {
+    const head = text.slice(0, promptWindowLimit * 2);
+    let redacted = Array.from(head).slice(0, promptWindowLimit).join("");
+    const windowCut = redacted.length < text.length;
+    redacted = redacted
+        .replace(/\/(?:Users|home)\/[^/\s]+/gu, "~")
+        .replace(/[A-Za-z]:\\Users\\[^\\/\s]+(\\)?/giu, (_match, separator) => (separator === undefined ? "~" : "~/"));
+    // The lookbehind starts a match only at the head of a run, which keeps the 8,000-character window linear.
+    redacted = redacted.replace(/(?<![A-Za-z0-9._%+-])[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}/gu, "[email]");
+    for (const pattern of secretPatterns)
+        redacted = redacted.replace(pattern, "[secret]");
+    const characters = Array.from(redacted);
+    if (!windowCut && characters.length <= promptCharacterLimit)
+        return redacted;
+    return characters.slice(0, promptCharacterLimit).join("").replace(tokenRunAtCut, "[secret]");
+}
+export function defaultJevCatalog() {
+    return litOpenCodeRuntimeSkills.map((skill) => ({ id: skill.id, description: skill.summary }));
+}
+export function buildJevRequestBody(state, catalog, model) {
+    const criteria = {};
+    for (const entry of catalog)
+        criteria[entry.id] = Array.from(entry.description).slice(0, descriptionCharacterLimit).join("");
+    criteria.none = noneCriterion;
+    return JSON.stringify({
+        model,
+        state,
+        questions: { which: { type: "choice", instructions: choiceInstructions, criteria } }
+    });
+}
+function boundedInteger(raw, fallback, min, max) {
+    if (raw === undefined || !/^\d+$/u.test(raw.trim()))
+        return fallback;
+    return Math.min(max, Math.max(min, Number(raw.trim())));
+}
+function minConfidence(raw) {
+    if (raw === undefined || raw.trim() === "")
+        return defaultMinConfidence;
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 0 && value <= 1 ? value : defaultMinConfidence;
+}
+async function readCappedBody(response) {
+    const declared = Number(response.headers.get("content-length") ?? "");
+    if (Number.isFinite(declared) && declared > bodyByteCap) {
+        await response.body?.cancel().catch(() => undefined);
+        return undefined;
+    }
+    if (response.body === null)
+        return "";
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        total += value.byteLength;
+        if (total > bodyByteCap) {
+            await reader.cancel().catch(() => undefined);
+            return undefined;
+        }
+        chunks.push(value);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+function validatedAnswer(raw, allowed, threshold) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { failure: "invalid response" };
+    }
+    const which = parsed?.answers?.which;
+    if (typeof which !== "object" || which === null)
+        return { failure: "invalid response" };
+    const { choice, confidence } = which;
+    if (typeof choice !== "string" || !allowed.has(choice))
+        return { failure: "invalid response" };
+    if (typeof confidence !== "number" || !Number.isFinite(confidence))
+        return { failure: "invalid response" };
+    if (choice === "none" || confidence < threshold)
+        return { confidence };
+    return { choice, confidence };
+}
+export function createJevSkillHint(options = {}) {
+    const env = options.env ?? process.env;
+    const fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
+    const now = options.now ?? Date.now;
+    const sessions = new Map();
+    async function trace(record) {
+        if (env[`${jevFlag}_TRACE`] !== "1" || options.traceFile === undefined)
+            return;
+        try {
+            await fs.mkdir(path.dirname(options.traceFile), { recursive: true });
+            // Refuse a symlink or other non-file at the trace path; O_NOFOLLOW closes the lstat race.
+            const existing = await fs.lstat(options.traceFile).catch(() => undefined);
+            if (existing !== undefined && !existing.isFile())
+                return;
+            const flags = fsConstants.O_WRONLY | fsConstants.O_APPEND | fsConstants.O_CREAT | (fsConstants.O_NOFOLLOW ?? 0);
+            const handle = await fs.open(options.traceFile, flags, 0o600);
+            try {
+                await handle.appendFile(`${JSON.stringify(record)}\n`, "utf8");
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch { // no-excuse-ok: catch -- the opt-in debug trace must never affect the turn.
+        }
+    }
+    async function ask(state, key) {
+        const catalog = options.catalog ?? defaultJevCatalog();
+        const model = (env[`${jevFlag}_MODEL`] ?? "").trim() || defaultModel;
+        const body = buildJevRequestBody(state, catalog, model);
+        if (Buffer.byteLength(body, "utf8") > bodyByteCap)
+            return { failure: "request too large" };
+        const timeoutMs = boundedInteger(env[`${jevFlag}_TIMEOUT_MS`], defaultTimeoutMs, 1, maxTimeoutMs);
+        const controller = new AbortController();
+        let timer;
+        const timedOut = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                controller.abort();
+                resolve({ failure: "timeout" });
+            }, timeoutMs);
+        });
+        const request = (async () => {
+            let response;
+            try {
+                response = await fetchImpl(jevEndpoint, {
+                    method: "POST",
+                    headers: { authorization: `Bearer ${key}`, "content-type": "application/json" },
+                    body,
+                    redirect: "error",
+                    signal: controller.signal
+                });
+            }
+            catch {
+                return { failure: controller.signal.aborted ? "timeout" : "network" };
+            }
+            if (response.status !== 200) {
+                await response.body?.cancel().catch(() => undefined);
+                return { httpStatus: response.status, failure: `HTTP ${response.status}` };
+            }
+            let raw;
+            try {
+                raw = await readCappedBody(response);
+            }
+            catch {
+                return { httpStatus: 200, failure: controller.signal.aborted ? "timeout" : "network" };
+            }
+            if (raw === undefined)
+                return { httpStatus: 200, failure: "response too large" };
+            const allowed = new Set([...catalog.map((entry) => entry.id), "none"]);
+            return { httpStatus: 200, ...validatedAnswer(raw, allowed, minConfidence(env[`${jevFlag}_MIN_CONFIDENCE`])) };
+        })();
+        try {
+            return await Promise.race([request, timedOut]);
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    return {
+        forget(sessionID) {
+            sessions.delete(sessionID);
+        },
+        claimAwareness(sessionID, promptText) {
+            if (jevSkillHintStatus(env) !== "on" || !isJevEligiblePrompt(promptText))
+                return false;
+            const session = sessions.get(sessionID) ?? { calls: 0, noted: false, announced: false };
+            sessions.set(sessionID, session);
+            if (session.announced)
+                return false;
+            session.announced = true;
+            return true;
+        },
+        async hintFor(sessionID, promptText) {
+            if (jevSkillHintStatus(env) !== "on" || !isJevEligiblePrompt(promptText))
+                return undefined;
+            const key = (env.TYPESAFE_API_KEY ?? "").trim();
+            const session = sessions.get(sessionID) ?? { calls: 0, noted: false, announced: false };
+            sessions.set(sessionID, session);
+            const started = now();
+            // A key pasted into the prompt is masked even when it is too short for a token shape.
+            const state = redactJevPrompt(promptText.split(key).join("[secret]"));
+            let outcome;
+            if (session.calls >= boundedInteger(env[`${jevFlag}_MAX_CALLS`], defaultMaxCalls, 0, Number.MAX_SAFE_INTEGER)) {
+                outcome = { failure: "call cap reached" };
+            }
+            else {
+                session.calls += 1;
+                try {
+                    outcome = await ask(state, key);
+                }
+                catch {
+                    outcome = { failure: "network" };
+                }
+            }
+            const latencyMs = now() - started;
+            await trace({
+                time: new Date(started).toISOString(),
+                promptSha256: createHash("sha256").update(state).digest("hex"),
+                choice: outcome.choice ?? null,
+                confidence: outcome.confidence ?? null,
+                latencyMs,
+                httpStatus: outcome.httpStatus ?? null,
+                fallback: outcome.failure ?? null
+            });
+            if (outcome.choice !== undefined) {
+                return { kind: "hint", text: jevSkillHintText(outcome.choice), skillId: outcome.choice, latencyMs };
+            }
+            if (outcome.failure === undefined || session.noted)
+                return undefined;
+            session.noted = true;
+            return { kind: "note", text: jevSkillHintUnavailableText(outcome.failure) };
+        }
+    };
+}

package/dist/server.js

@@ -1,5 +1,6 @@
+import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { createChatMessageActivationHook, showActivationToast } from "./activation.js";
+import { createChatMessageActivationHook, showActivationToast, showJevSkillHintToast } from "./activation.js";
 import { registerLitOpenCodeAgents } from "./agents.js";
 import { createBoundedAuthorityEventHook } from "./bounded-authority-hooks.js";
 import { createCommandActivationHook } from "./commands.js";
@@ -7,6 +8,7 @@ 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";
@@ -52,7 +54,10 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
             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,
@@ -66,6 +71,9 @@ 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);
             },
@@ -78,20 +86,28 @@ export function createLitOpenCodePlugin(autoUpdateRunner = runPluginAutoUpdate)
                     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) => {

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.9"><title>release: 1.0.9</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.9</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

package/docs/reference-Ko-KR.md

@@ -253,6 +253,45 @@ npm uninstall -g @litfamily/litopencode
 - 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` 가운데 하나로 나옵니다.
+
+| 변수 | 기본값 | 효과 |
+| --- | --- | --- |
+| `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

@@ -364,6 +364,49 @@ when discarding that project's ledger and receipts is intentional.
   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`.
+
+| 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`