@litfamily/litopencode 1.0.7 → 1.0.10

package/dist/features.js

@@ -917,33 +917,39 @@ export const litOpenCodeFeatures = Object.freeze([
         ]
     },
     {
-        id: "lit-korean",
-        title: "Lit Korean",
-        summary: "Documents a static review workflow for making Korean prose sound natural while reducing overwrought phrasing and preserving meaning.",
+        id: "lit-humanizer",
+        title: "Lit Humanizer",
+        summary: "Revises reader-facing prose for its audience and genre while preserving voice, meaning, evidence, citations, and useful qualifiers.",
         bindings: [
             {
                 kind: "config",
                 id: "litOpenCodeRuntimeSkills",
                 surface: "litopencode exported runtime skill catalog",
-                description: "Exposes the lit-korean skill as discoverable static guidance without adding hooks, tools, or rewriting behavior."
+                description: "Exposes the lit-humanizer skill through the native runtime catalog, prompt route, package assets, and tool guard."
             },
             {
                 kind: "command",
-                id: "lit-korean",
-                surface: "OpenCode command /lit-korean",
-                description: "Makes Korean prose naturalization guidance visible as an installed OpenCode command alias."
+                id: "lit-humanizer",
+                surface: "OpenCode command /lit-humanizer",
+                description: "Provides the canonical prose revision route and loads the installed skill guidance."
             },
             {
                 kind: "command",
-                id: "text-neutralization",
-                surface: "OpenCode command /text-neutralization",
-                description: "Makes restrained Korean prose neutralization guidance visible as an installed OpenCode command alias."
+                id: "tool.execute.before",
+                surface: "OpenCode write/edit pre-tool hook",
+                description: "Blocks new high-confidence detector hits before supported reader-facing text files are saved."
             },
             {
                 kind: "config",
-                id: "skills/lit-korean/SKILL.md",
+                id: "skills/lit-humanizer/SKILL.md",
                 surface: "LitOpenCode visible static skills corpus",
-                description: "Provides the prose-review checklist, safety notes, and verification route for agents and package consumers."
+                description: "Provides the full language, format, safety, detector, Office extraction, and verification guidance for native skill users."
+            },
+            {
+                kind: "config",
+                id: "rules/bundled-rules/lit-humanizer.md",
+                surface: "OpenCode experimental.chat.system.transform hook",
+                description: "Applies the compact always-on writing rule on each eligible OpenCode chat turn."
             }
         ],
         verification: ["node --test test/runtime-skills.test.mjs", "node --test test/docs.test.mjs"]
@@ -971,7 +977,7 @@ export const litOpenCodeFeatures = Object.freeze([
     {
         id: "lit-comprehend",
         title: "Lit Comprehend",
-        summary: "Builds a self-contained explainer artifact so the user can reason about work that was already done, with delta-anchored themes, intuition-first diagrams, micro-worlds, and an honesty ledger.",
+        summary: "Builds a self-contained explainer so the user can understand completed work through delta-anchored themes, diagrams, and interactive examples.",
         bindings: [
             {
                 kind: "command",
@@ -1058,6 +1064,67 @@ export const litOpenCodeFeatures = Object.freeze([
         ],
         verification: ["node --test test/lit-scientific-visualization.test.mjs", "npm run check:pack-payload"]
     },
+    {
+        id: "lit-diagram-drawer",
+        title: "Diagram Drawer",
+        summary: "Installs an OpenCode native skill with pinned diagram guides, templates, local verifiers, safe importers, and an exporter that never installs dependencies.",
+        bindings: [
+            {
+                kind: "config",
+                id: "skills/lit-diagram-drawer/SKILL.md",
+                surface: "OpenCode native skill picker",
+                description: "Selects the bounded diagram workflow and its complete managed skill tree. Bounded lit diagram requests direct the model to this native picker; no dedicated slash or standalone diagram chat route is registered."
+            },
+            {
+                kind: "cli",
+                id: "litopencode install",
+                surface: "LitOpenCode managed native skill installer",
+                description: "Installs every hash-pinned guide, template, example, tool, font, and license asset."
+            },
+            {
+                kind: "cli",
+                id: "litopencode doctor",
+                surface: "LitOpenCode managed native skill doctor",
+                description: "Verifies the exact installed file closure and reports export capabilities without installing tools."
+            }
+        ],
+        verification: ["node --test test/lit-diagram-drawer.test.mjs", "npm run check:managed-skill-manifest", "npm run check:pack-payload"]
+    },
+    {
+        id: "lit-typographic-motion",
+        title: "Film director",
+        summary: "Native OpenCode film director: treatment first, a captured stage page or the type engine, generated sound, a numeric gate and recorded look rounds.",
+        bindings: [
+            { kind: "config", id: "skills/lit-typographic-motion/SKILL.md", surface: "OpenCode native skill picker", description: "Loads the managed motion skill and its engine and reference closure." },
+            { kind: "hook", id: "lit-task motion-video intent", surface: "OpenCode chat.message activation", description: "Routes bounded film requests before slide and interface guidance with a neutral film context." },
+            { kind: "hook", id: "tool.execute.after", surface: "OpenCode tool.execute.after hook", description: "Records each read of a film's stills so the done check can confirm the frames were viewed." },
+            { kind: "cli", id: "litopencode motion-runtime install|status", surface: "LitOpenCode runtime", description: "Pre-warms pinned dependencies and fonts outside the render session." },
+            { kind: "cli", id: "litopencode doctor", surface: "LitOpenCode doctor", description: "Reports Chrome, ffmpeg, WebGL2 tier, software warning, and pre-warm status." }
+        ],
+        verification: ["node --test test/lit-typographic-motion.test.mjs", "npm run check:managed-skill-manifest", "npm run check:pack-payload"]
+    },
+    {
+        id: "lit-pptx",
+        title: "Lit PowerPoint",
+        summary: "Native OpenCode deck skill with source, compile, QA, fonts, and first-use dependency cache.",
+        bindings: [
+            { kind: "config", id: "skills/lit-pptx/SKILL.md", surface: "OpenCode native skill picker", description: "Loads the slide workflow from the installed managed tree." },
+            { kind: "hook", id: "lit-task slide intent", surface: "OpenCode chat.message activation", description: "Directs bounded lit slide requests to the native skill." },
+            { kind: "cli", id: "litopencode doctor", surface: "LitOpenCode doctor", description: "Reports installed skill integrity and office runtime readiness." }
+        ],
+        verification: ["node --test test/lit-office-docs.test.mjs", "npm run check:pack-payload"]
+    },
+    {
+        id: "lit-docx",
+        title: "Lit Word Documents",
+        summary: "Native OpenCode document skill with publisher profiles, conversion, editing, lint, and first-use dependency cache.",
+        bindings: [
+            { kind: "config", id: "skills/lit-docx/SKILL.md", surface: "OpenCode native skill picker", description: "Loads the document workflow from the installed managed tree." },
+            { kind: "hook", id: "lit-task report intent", surface: "OpenCode chat.message activation", description: "Directs bounded lit report requests to the native skill." },
+            { kind: "cli", id: "litopencode doctor", surface: "LitOpenCode doctor", description: "Reports installed skill integrity and office runtime readiness." }
+        ],
+        verification: ["node --test test/lit-office-docs.test.mjs", "npm run check:pack-payload"]
+    },
     frontendUiUxFeature,
     {
         id: "readme-studio", title: "README Studio",

package/dist/hooks.d.ts

@@ -1,16 +1,17 @@
 import type { Hooks } from "@opencode-ai/plugin";
 import type { SessionLookup } from "./session-lineage.ts";
-import { type DeliverableHedgeSessionState } from "./deliverable-hedge-guard.ts";
+import type { DeliverableHedgeGuardState } from "./deliverable-hedge-guard.ts";
 type ToolExecuteBeforeHook = NonNullable<Hooks["tool.execute.before"]>;
 type ToolExecuteAfterHook = NonNullable<Hooks["tool.execute.after"]>;
 export type ToolExecuteHookOptions = {
     readonly getSession?: SessionLookup;
+    readonly deliverableHedgeGuard?: DeliverableHedgeGuardState;
 };
 export declare function createToolExecuteBeforeHook(options?: ToolExecuteHookOptions): ToolExecuteBeforeHook;
 export type ToolExecuteAfterHookOptions = {
     readonly projectRoot?: string;
     readonly knowledgeCaptureEnabled?: boolean;
-    readonly deliverableHedgeState?: DeliverableHedgeSessionState;
+    readonly deliverableHedgeGuard?: DeliverableHedgeGuardState;
     readonly onSkillActivation?: (sessionID: string, skillId: string) => void | Promise<void>;
 };
 export declare function createToolExecuteAfterHook(options?: ToolExecuteAfterHookOptions): ToolExecuteAfterHook;

package/dist/hooks.js

@@ -1,18 +1,20 @@
 import { activationBanner } from "./activation-probe.js";
-import { applyDeliverableHedgeAfterHook } from "./deliverable-hedge-guard.js";
 import { dynamicRulesForPaths } from "./rules/hooks.js";
 import { applyLitOpenCodePostEditHook, applyLitOpenCodeToolAfterHook, applyLitOpenCodeToolBeforeHook, applyTaskRecursionGuard, mutatedFilePaths } from "./tool-guards.js";
 import { captureKnowledgeEvent } from "./knowledge.js";
+import { recordMotionImageRead } from "./motion-image-reads.js";
 export function createToolExecuteBeforeHook(options = {}) {
     return async (input, output) => {
         await applyTaskRecursionGuard(input, options.getSession);
         applyLitOpenCodeToolBeforeHook(input, output);
+        await options.deliverableHedgeGuard?.before(input);
     };
 }
 export function createToolExecuteAfterHook(options = {}) {
     return async (input, output) => {
         applyLitOpenCodeToolAfterHook(input, output);
         applyLitOpenCodePostEditHook(input, output);
+        recordMotionImageRead(input, options.projectRoot);
         const activationAction = input.tool === "lit" ? "activate"
             : input.tool === "litwork" || input.tool === "start-work" ? "start"
                 : input.tool === "review-work" ? "review" : undefined;
@@ -21,9 +23,7 @@ export function createToolExecuteAfterHook(options = {}) {
             output.output.startsWith(`${activationBanner(input.tool)}\n`)) {
             await options.onSkillActivation?.(input.sessionID, input.tool);
         }
-        if (options.deliverableHedgeState !== undefined) {
-            await applyDeliverableHedgeAfterHook(options.deliverableHedgeState, input, output);
-        }
+        await options.deliverableHedgeGuard?.after(input, output);
         if (options.projectRoot !== undefined && output.metadata?.litopencodeKnowledgeCapture !== undefined) {
             const request = output.metadata.litopencodeKnowledgeCapture;
             const metadata = { ...output.metadata };

package/dist/ignition.d.ts

@@ -1,6 +1,6 @@
 export declare function ignitionMark(first: boolean, _discipline: string, env?: NodeJS.ProcessEnv): string;
 export declare function createIgnitionState(): {
-    activate(sessionID: string, skillId: string): void;
+    activate(sessionID: string, skillId: string, showCompletionMark?: boolean): void;
     resetDiscipline(sessionID: string): void;
     clear(sessionID: string): void;
     complete: (input: {

package/dist/ignition.js

@@ -8,6 +8,7 @@ export function ignitionMark(first, _discipline, env = process.env) {
 export function createIgnitionState() {
     const seen = new Set();
     const disciplines = new Map();
+    const plainCompletions = new Set();
     let disposed = false;
     const complete = async (input, output) => {
         const text = stripUserFacingBlankHtmlCommentLines(output.text);
@@ -15,15 +16,25 @@ export function createIgnitionState() {
             output.text = text;
             return;
         }
+        if (plainCompletions.has(input.sessionID)) {
+            output.text = text;
+            return;
+        }
         const mark = ignitionMark(!seen.has(input.sessionID), disciplines.get(input.sessionID) ?? "lit-loop");
         seen.add(input.sessionID);
         output.text = `${mark}${text === "" ? "" : `\n\n${text}`}`;
     };
     return {
-        activate(sessionID, skillId) { disciplines.set(sessionID, skillId); },
-        resetDiscipline(sessionID) { disciplines.delete(sessionID); },
-        clear(sessionID) { seen.delete(sessionID); disciplines.delete(sessionID); },
+        activate(sessionID, skillId, showCompletionMark = true) {
+            disciplines.set(sessionID, skillId);
+            if (showCompletionMark)
+                plainCompletions.delete(sessionID);
+            else
+                plainCompletions.add(sessionID);
+        },
+        resetDiscipline(sessionID) { disciplines.delete(sessionID); plainCompletions.delete(sessionID); },
+        clear(sessionID) { seen.delete(sessionID); disciplines.delete(sessionID); plainCompletions.delete(sessionID); },
         complete,
-        dispose() { seen.clear(); disciplines.clear(); disposed = true; }
+        dispose() { seen.clear(); disciplines.clear(); plainCompletions.clear(); disposed = true; }
     };
 }

package/dist/index.d.ts

@@ -7,7 +7,7 @@ export { defaultGlobalConfigFile, defaultGlobalConfigJson, effectiveAgentConfig,
 export { captureKnowledgeEvent, inspectKnowledge, knowledgeKinds, knowledgePaths, knowledgeStates, queryKnowledge, readKnowledgeClaims, recoverKnowledge, reviewKnowledgeRecord, KnowledgeStoreError, type KnowledgeCaptureResult, type KnowledgeEvent, type KnowledgeKind, type KnowledgePaths, type KnowledgeQueryResult, type KnowledgeRecord, type KnowledgeReviewResult, type KnowledgeState } from "./knowledge.ts";
 export { litActivationBanner, litOpenCodeCommands } from "./commands.ts";
 export { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.ts";
-export { applyDeliverableHedgeAfterHook, artifactGenres, createDeliverableHedgeSessionState, inspectDeliverableHedges, readOutputChannelContract, type ArtifactGenre, type DeliverableHedgeFinding, type DeliverableHedgeSessionState, type HedgeClass, type LimitationsChannel, type OutputChannelContract } from "./deliverable-hedge-guard.ts";
+export { createDeliverableHedgeGuard, type DeliverableHedgeGuardOptions, type DeliverableHedgeGuardState, type HumanizerFinding, type HumanizerScan, type HumanizerScanRequest } from "./deliverable-hedge-guard.ts";
 export { activationRegexMetric, createProviderUsageReceiptEventHook, emptyProviderCacheMeasurement, providerUsageReceiptFromEvent, recordProviderUsageReceipt, ruleDedupMetric, updateCacheMetric, type ProviderCacheMeasurement, type ProviderUsageReceipt, type ProviderUsageReceiptEventOptions, type RuleDedupMetric, type ActivationRegexMetric, type UpdateCacheMetric } from "./cache-metrics.ts";
 export { benchmarkGateAllowsStrongClaim, classifyReferenceSuperiorityClaim, certifyDeclaredBenchmarkUniverse, litOpenCodeClaimPolicy, litOpenCodeReferenceBenchmark, renderDeclaredBenchmarkUniverseClaim, type LitOpenCodeBenchmarkGateInput, type LitOpenCodeBenchmarkScoringDimension, type LitOpenCodeBenchmarkTaskCategory, type LitOpenCodeBenchmarkTaskResult, type LitOpenCodeBenchmarkTaskWinner, type LitOpenCodeBenchmarkUniverseCertification, type LitOpenCodeBenchmarkUniverseCertificationInput, type LitOpenCodeClaimClassification, type LitOpenCodeClaimPolicy, type LitOpenCodeClaimVerdict, type LitOpenCodeReferenceBenchmark } from "./benchmark.ts";
 export { completeGoals, countRecordedEvidence, createGoals, criterionStatuses, evaluateGoalGate, evidenceKinds, EvidenceLedgerError, evidenceLedgerVersion, goalStatuses, readEvidenceLedger, readEvidenceLedgerStatus, recordCheckpoint, recordEvidence, recordReviewBlocker, recordSteering, renderEvidenceBrief, steeringKinds, steeringWeakeningReason, type Checkpoint, type Criterion, type CriterionStatus, type EvidenceEntry, type EvidenceKind, type EvidenceLedgerState, type GateVerdict, type Goal, type GoalStatus, type ReviewBlocker, type SteeringEntry, type SteeringKind } from "./ledger.ts";

package/dist/index.js

@@ -7,7 +7,7 @@ export { defaultGlobalConfigFile, defaultGlobalConfigJson, effectiveAgentConfig,
 export { captureKnowledgeEvent, inspectKnowledge, knowledgeKinds, knowledgePaths, knowledgeStates, queryKnowledge, readKnowledgeClaims, recoverKnowledge, reviewKnowledgeRecord, KnowledgeStoreError } from "./knowledge.js";
 export { litActivationBanner, litOpenCodeCommands } from "./commands.js";
 export { createToolExecuteAfterHook, createToolExecuteBeforeHook } from "./hooks.js";
-export { applyDeliverableHedgeAfterHook, artifactGenres, createDeliverableHedgeSessionState, inspectDeliverableHedges, readOutputChannelContract } from "./deliverable-hedge-guard.js";
+export { createDeliverableHedgeGuard } from "./deliverable-hedge-guard.js";
 export { activationRegexMetric, createProviderUsageReceiptEventHook, emptyProviderCacheMeasurement, providerUsageReceiptFromEvent, recordProviderUsageReceipt, ruleDedupMetric, updateCacheMetric } from "./cache-metrics.js";
 export { benchmarkGateAllowsStrongClaim, classifyReferenceSuperiorityClaim, certifyDeclaredBenchmarkUniverse, litOpenCodeClaimPolicy, litOpenCodeReferenceBenchmark, renderDeclaredBenchmarkUniverseClaim } from "./benchmark.js";
 export { completeGoals, countRecordedEvidence, createGoals, criterionStatuses, evaluateGoalGate, evidenceKinds, EvidenceLedgerError, evidenceLedgerVersion, goalStatuses, readEvidenceLedger, readEvidenceLedgerStatus, recordCheckpoint, recordEvidence, recordReviewBlocker, recordSteering, renderEvidenceBrief, steeringKinds, steeringWeakeningReason } from "./ledger.js";

package/dist/interface-handoff.d.ts

@@ -0,0 +1 @@
+export declare const interfaceWorkHandoff = "If the work creates or changes a user-facing web interface, include its UI slice in the plan and verification: load frontend-ui-ux, follow its build guidance, and run node scripts/probe.mjs --path <entry.html> --out <evidence-dir> against the finished page. Require the full RS matrix; fix remaining measured or derived HIGH findings before claiming done, and report exit 2 as blocked. A --help call or ad hoc screenshot does not substitute for the page probe. For CLI or backend-only work, do not load the interface skill or run its probe.";

package/dist/interface-handoff.js

@@ -0,0 +1 @@
+export const interfaceWorkHandoff = "If the work creates or changes a user-facing web interface, include its UI slice in the plan and verification: load frontend-ui-ux, follow its build guidance, and run node scripts/probe.mjs --path <entry.html> --out <evidence-dir> against the finished page. Require the full RS matrix; fix remaining measured or derived HIGH findings before claiming done, and report exit 2 as blocked. A --help call or ad hoc screenshot does not substitute for the page probe. For CLI or backend-only work, do not load the interface skill or run its probe.";

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/motion-image-reads.d.ts

@@ -0,0 +1,6 @@
+export type MotionImageReadInput = {
+    readonly tool: string;
+    readonly args?: unknown;
+};
+export declare function motionRunDirFor(file: string): string | undefined;
+export declare function recordMotionImageRead(input: MotionImageReadInput, cwd?: string): void;