@litfamily/litclaude 1.0.10 → 1.0.13

package/bin/install-ownership.mjs

@@ -1,5 +1,5 @@
-import { createHash } from "node:crypto";
-import { lstatSync, readFileSync, readdirSync, readlinkSync, renameSync, rmdirSync, writeFileSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, rmSync, rmdirSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { compareStableSemver } from "./update-notifier.mjs";
 
@@ -53,20 +53,159 @@ function treeHash(root) {
   return createHash("sha256").update(JSON.stringify(entries)).digest("hex");
 }
 
-export function assertOwnedTree(path, kind, version, { allowPreviousVersion = false } = {}) {
+function detailedTree(root, { receipt = false } = {}) {
+  const rows = [];
+  function walk(path, prefix = "") {
+    const value = lstatSync(path);
+    if (value.isSymbolicLink()) conflict(path, "A preserved skill tree cannot contain symlinks");
+    if (value.isDirectory()) {
+      rows.push([prefix, "directory", value.mode & 0o777]);
+      for (const name of readdirSync(path).sort()) {
+        if (!prefix && !receipt && name === receiptName) continue;
+        walk(join(path, name), prefix ? `${prefix}/${name}` : name);
+      }
+      return;
+    }
+    if (!value.isFile() || value.nlink !== 1) conflict(path, "A preserved skill tree must contain only regular, unlinked files");
+    rows.push([prefix, "file", value.mode & 0o777, createHash("sha256").update(readFileSync(path)).digest("hex")]);
+  }
+  walk(root);
+  return rows;
+}
+
+const rowsHash = (rows) => createHash("sha256").update(JSON.stringify(rows)).digest("hex");
+const treeMap = (rows) => new Map(rows.map((row) => [row[0], row]));
+const sameRow = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const ownKeys = (value, keys) => value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((key) => keys.includes(key));
+
+const readPluginReceipt = (pluginRoot) => {
+  const path = join(pluginRoot, receiptName), value = stat(path);
+  if (!value || !value.isFile() || value.nlink !== 1 || value.size > 2048) conflict(path, "Skill preservation requires a valid active plugin receipt");
+  try { return JSON.parse(readFileSync(path, "utf8")); } catch { conflict(path, "Active plugin receipt is invalid"); }
+};
+
+export function registeredPluginInstallation({ registry, pluginKey, pluginParent, home, version }) {
+  const entries = registry.plugins?.[pluginKey];
+  if (entries === undefined) return null;
+  if (!Array.isArray(entries) || entries.length !== 1) conflict("native registration " + pluginKey);
+  const entry = entries[0];
+  if (!ownKeys(entry, ["scope", "installPath", "version", "installedAt", "lastUpdated", "installedBy", "enabled"])
+    || entry.scope !== "user" || (entry.installedBy !== undefined && entry.installedBy !== "litclaude-ai")
+    || typeof entry.version !== "string" || !stableVersion.test(entry.version)
+    || compareStableSemver(entry.version, version) > 0 || entry.installPath !== join(pluginParent, entry.version)) {
+    conflict("native registration " + pluginKey);
+  }
+  assertInstallPath(home, entry.installPath);
+  return { installPath: entry.installPath, version: entry.version };
+}
+
+export function planModifiedLegacySkill({ activePlugin, marketplacePlugin, compatibilityPlugin, version, installedVersion = version, marketplaceVersion = installedVersion }) {
+  if (!stat(activePlugin)) return null;
+  const skillPath = join(activePlugin, "skills", "lit-korean");
+  if (!stat(skillPath)) return null;
+  if (!stableVersion.test(installedVersion) || compareStableSemver(installedVersion, version) > 0) {
+    conflict(activePlugin, "The registered plugin version is not a supported installed version");
+  }
+  if (!stat(marketplacePlugin) || !stat(compatibilityPlugin)) {
+    conflict(marketplacePlugin, "Redundant pristine plugin copies are missing; modified-skill preservation is unavailable");
+  }
+  const active = detailedTree(activePlugin);
+  const marketplace = detailedTree(marketplacePlugin);
+  const compatibility = detailedTree(compatibilityPlugin);
+  if (marketplace.some((row, index) => !sameRow(row, compatibility[index])) || marketplace.length !== compatibility.length) {
+    conflict(marketplacePlugin, "Redundant pristine plugin copies do not match; modified-skill preservation is unavailable");
+  }
+  const receipt = readPluginReceipt(activePlugin);
+  const peerDigest = treeHash(marketplacePlugin);
+  if (receipt?.schema !== "litclaude.install-ownership/v1" || receipt.owner !== "litclaude-ai" || receipt.kind !== "plugin" || receipt.version !== installedVersion || receipt.sha256 !== peerDigest) {
+    conflict(activePlugin, "Active plugin receipt does not authenticate the pristine redundant copies");
+  }
+
+  const activeByPath = treeMap(active), peerByPath = treeMap(marketplace);
+  const changed = new Set([...activeByPath.keys(), ...peerByPath.keys()].filter((path) => !sameRow(activeByPath.get(path), peerByPath.get(path))));
+  if (changed.size === 0) return null;
+  if (marketplaceVersion !== installedVersion) {
+    conflict(marketplacePlugin, "Marketplace and active plugin receipts do not identify the same installed version");
+  }
+  const legacyPrefix = "skills/lit-korean/";
+  if ([...changed].some((path) => path !== "skills/lit-korean" && !path.startsWith(legacyPrefix))) {
+    conflict(activePlugin, "Only changes under skills/lit-korean can be preserved automatically");
+  }
+  const skillStat = stat(skillPath);
+  if (!skillStat || !skillStat.isDirectory() || skillStat.isSymbolicLink()) {
+    conflict(skillPath, "The modified legacy skill has no safe copy to preserve");
+  }
+  const skillRows = detailedTree(skillPath, { receipt: true });
+  return { activePlugin, skillPath, version: installedVersion, skillRows, sha256: rowsHash(skillRows) };
+}
+
+export function preserveModifiedLegacySkill(plan, litHome) {
+  if (!plan) return null;
+  const parent = join(litHome, "preserved-skills", "lit-korean", plan.version);
+  const destination = join(parent, plan.sha256);
+  const savedSkill = join(destination, "skill");
+  assertInstallPath(litHome, destination);
+  const verifySaved = () => {
+    const metadataPath = join(destination, "preservation.json"), metadataStat = stat(metadataPath);
+    if (!metadataStat || !metadataStat.isFile() || metadataStat.nlink !== 1 || metadataStat.size > 2048) conflict(destination, "An existing preservation path has no valid receipt");
+    let metadata;
+    try { metadata = JSON.parse(readFileSync(metadataPath, "utf8")); } catch { conflict(metadataPath, "Preservation receipt is invalid"); }
+    if (metadata?.schema !== "litclaude.preserved-skill/v1" || metadata.skill !== "lit-korean" || metadata.version !== plan.version || metadata.sha256 !== plan.sha256) {
+      conflict(destination, "An existing preservation path has conflicting provenance");
+    }
+    if (!sameRowList(detailedTree(savedSkill, { receipt: true }), plan.skillRows)) conflict(destination, "An existing preservation copy does not match the user-modified skill");
+  };
+  if (existsSync(destination)) {
+    verifySaved();
+    return destination;
+  }
+
+  mkdirSync(parent, { recursive: true });
+  assertInstallPath(litHome, parent);
+  const staging = join(parent, `.preserve-${randomUUID()}`);
+  mkdirSync(staging, { recursive: false });
+  try {
+    const currentRows = detailedTree(plan.skillPath, { receipt: true });
+    if (!sameRowList(currentRows, plan.skillRows)) conflict(plan.skillPath, "The legacy skill changed after the ownership preflight");
+    cpSync(plan.skillPath, join(staging, "skill"), { recursive: true, errorOnExist: true, force: false });
+    if (!sameRowList(detailedTree(join(staging, "skill"), { receipt: true }), plan.skillRows)) {
+      conflict(plan.skillPath, "The staged preservation copy does not match the source");
+    }
+    writeFileSync(join(staging, "preservation.json"), `${JSON.stringify({
+      schema: "litclaude.preserved-skill/v1", skill: "lit-korean", version: plan.version, sha256: plan.sha256,
+    }, null, 2)}\n`, { flag: "wx" });
+    assertInstallPath(litHome, parent);
+    renameSync(staging, destination);
+  } catch (error) {
+    rmSync(staging, { recursive: true, force: true });
+    throw error;
+  }
+  verifySaved();
+  return destination;
+}
+
+function sameRowList(left, right) {
+  return left.length === right.length && left.every((row, index) => sameRow(row, right[index]));
+}
+
+export function assertOwnedTree(path, kind, version, { allowPreviousVersion = false, requirePresent = false } = {}) {
   const value = stat(path);
-  if (!value) return;
+  if (!value) {
+    if (requirePresent) conflict(path, "A registered installation tree is missing");
+    return null;
+  }
   if (!value.isDirectory() || value.isSymbolicLink()) conflict(path);
   const receiptPath = join(path, receiptName), receiptStat = stat(receiptPath);
   const digest = treeHash(path);
   if (!receiptStat) {
-    if ((version === legacyVersion || (allowPreviousVersion && compareStableSemver(legacyVersion, version) <= 0)) && legacy046[kind] === digest) return;
+    if ((version === legacyVersion || (allowPreviousVersion && compareStableSemver(legacyVersion, version) <= 0)) && legacy046[kind] === digest) return legacyVersion;
     conflict(path, "No ownership receipt; this tree is not a supported pristine legacy baseline for the requested version. Do not move only the reported directory. Review the connected installation or use a separate trial profile; see package docs/migration.md#ownership-conflicts.");
   }
   if (!receiptStat.isFile() || receiptStat.nlink !== 1 || receiptStat.size > 2048) conflict(receiptPath);
   let receipt;
   try { receipt = JSON.parse(readFileSync(receiptPath, "utf8")); } catch { conflict(receiptPath); }
   if (receipt?.schema !== "litclaude.install-ownership/v1" || receipt.owner !== "litclaude-ai" || receipt.kind !== kind || (typeof receipt.version !== "string" || !stableVersion.test(receipt.version) || (allowPreviousVersion ? compareStableSemver(receipt.version, version) > 0 : receipt.version !== version)) || receipt.sha256 !== digest) conflict(path);
+  return receipt.version;
 }
 
 export function migrateLegacyVendorPaths(receiptRoot, vendorRoot, kind, version) {
@@ -105,19 +244,23 @@ export function writeOwnershipReceipt(path, kind, version) {
   writeFileSync(join(path, receiptName), `${JSON.stringify({ schema: "litclaude.install-ownership/v1", owner: "litclaude-ai", kind, version, sha256: treeHash(path) }, null, 2)}\n`, { flag: "wx" });
 }
 
-export function assertCurrentPointer(home, current, target, version) {
+export function assertCurrentPointer(home, current, target, version, { expectedVersion } = {}) {
   assertInstallPath(home, dirname(current));
   const value = stat(current);
-  if (!value) return;
+  if (!value) return null;
+  let currentVersion;
   if (value.isSymbolicLink()) {
     const linked = resolve(dirname(current), readlinkSync(current));
     const linkedVersion = relative(dirname(target), linked);
     if (!stableVersion.test(linkedVersion) || compareStableSemver(linkedVersion, version) > 0 || !stat(linked)) conflict(current);
     assertInstallPath(home, linked);
     assertOwnedTree(linked, "compatibility", linkedVersion);
+    currentVersion = linkedVersion;
   } else {
-    assertOwnedTree(current, "compatibility", version, { allowPreviousVersion: true });
+    currentVersion = assertOwnedTree(current, "compatibility", version, { allowPreviousVersion: true });
   }
+  if (expectedVersion && currentVersion !== expectedVersion) conflict(current, "The active plugin registration and compatibility pointer do not match");
+  return currentVersion;
 }
 
 export function removeEmptyDirectory(path) {
@@ -125,17 +268,11 @@ export function removeEmptyDirectory(path) {
 }
 
 
-export function assertOwnedRegistrations({ registry, settings, marketplaces, pluginKey, marketplaceName, marketplacePath, pluginParent, home, version }) {
-  const ownKeys = (value, keys) => value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((key) => keys.includes(key));
+export function assertOwnedRegistrations({ registry, settings, marketplaces, pluginKey, marketplaceName, marketplacePath, pluginParent, home, version, modifiedPluginRoot, modifiedPluginVersion }) {
   const sourceMatches = (value) => ownKeys(value, ["source", "path"]) && value.source === "directory" && value.path === marketplacePath;
-  const entries = registry.plugins?.[pluginKey];
-  if (entries !== undefined) {
-    if (!Array.isArray(entries) || entries.length !== 1) conflict(`native registration ${pluginKey}`);
-    const entry = entries[0];
-    // Hosts may rewrite the registry without installedBy/enabled; a different installedBy stays foreign.
-    if (!ownKeys(entry, ["scope", "installPath", "version", "installedAt", "lastUpdated", "installedBy", "enabled"]) || entry.scope !== "user" || (entry.installedBy !== undefined && entry.installedBy !== "litclaude-ai") || typeof entry.version !== "string" || !stableVersion.test(entry.version) || compareStableSemver(entry.version, version) > 0 || entry.installPath !== join(pluginParent, entry.version)) conflict(`native registration ${pluginKey}`);
-    assertInstallPath(home, entry.installPath);
-    assertOwnedTree(entry.installPath, "plugin", entry.version);
+  const registration = registeredPluginInstallation({ registry, pluginKey, pluginParent, home, version });
+  if (registration && !(registration.installPath === modifiedPluginRoot && registration.version === modifiedPluginVersion)) {
+    assertOwnedTree(registration.installPath, "plugin", registration.version);
   }
   const hud = settings.litclaude;
   if (hud?.statusLineManaged === true && (typeof hud.statusLineVersion !== "string" || !stableVersion.test(hud.statusLineVersion) || compareStableSemver(hud.statusLineVersion, version) > 0)) conflict("managed HUD version");

package/bin/litclaude-ai.js

@@ -14,7 +14,7 @@ import { cp, mkdir, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 import {
   canonicalSkillFiles,
   canonicalSkillIds,
@@ -40,15 +40,33 @@ import { runLitgoalCli } from "../plugins/litclaude/lib/litgoal/cli.mjs";
 import { runWorkflowCheckCli } from "../plugins/litclaude/lib/workflow-check.mjs";
 import { runWikifyKnowledgeCli } from "../plugins/litclaude/lib/wikify-knowledge-cli.mjs";
 import { automaticUpdateRoot, runAutomaticUpdate } from "../plugins/litclaude/lib/automatic-update.mjs";
+import { jevStatusLine } from "../plugins/litclaude/lib/jev-skill-hint.mjs";
 import { runUpdateNotifier } from "./update-notifier.mjs";
-import { assertInstallPath, assertOwnedTree, assertCurrentPointer, assertOwnedRegistrations, migrateLegacyVendorPaths, writeOwnershipReceipt, removeEmptyDirectory } from "./install-ownership.mjs";
+import { assertInstallPath, assertOwnedTree, assertCurrentPointer, assertOwnedRegistrations, migrateLegacyVendorPaths, planModifiedLegacySkill, preserveModifiedLegacySkill, registeredPluginInstallation, writeOwnershipReceipt, removeEmptyDirectory } from "./install-ownership.mjs";
 import { banner, lockup, colorMode, supportsBlocks, terminalRows } from "./litfamily-banner.mjs";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const packageJson = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+const motionSkillScripts = join(root, "plugins", "litclaude", "skills", "lit-typographic-motion", "scripts");
+
+// lit-typographic-motion pre-warm, attempted by install (and so by the global npm postinstall).
+// A failure never fails the install: it prints one receipt line naming the command. The cache is
+// only ever written by this step or by \`litclaude-ai motion-runtime install\`, never by a render.
+const prewarmMotionRuntime = () => {
+  if (process.env.LITCLAUDE_MOTION_PREWARM === "0") {
+    return "MOTION_RUNTIME: pre-warm skipped (LITCLAUDE_MOTION_PREWARM=0); run: litclaude-ai motion-runtime install";
+  }
+  const result = spawnSync(process.execPath, [join(motionSkillScripts, "motion-runtime.mjs"), "install"], {
+    encoding: "utf8",
+    timeout: Number(process.env.LITCLAUDE_MOTION_PREWARM_TIMEOUT_MS ?? 600000),
+  });
+  if (result.status === 0) return "MOTION_RUNTIME: pre-warmed (engine deps and fonts ready)";
+  const why = `${result.stderr || result.error?.message || "unknown error"}`.trim().split("\n").filter(Boolean).pop()?.slice(0, 200) ?? "unknown error";
+  return `MOTION_RUNTIME: not pre-warmed (${why}); run: litclaude-ai motion-runtime install`;
+};
 const version = packageJson.version;
 
-const usage = `Usage: litclaude-ai [--dry-run] <install|doctor|path|run|update|uninstall|litgoal|wikify|workflow-check|start-work|start-work-next|public-read> [...args]
+const usage = `Usage: litclaude-ai [--dry-run] <install|doctor|path|run|update|uninstall|litgoal|wikify|workflow-check|start-work|start-work-next|public-read|motion-runtime> [...args]
        litclaude-ai --version
 
 Commands:
@@ -62,6 +80,8 @@ Commands:
   start-work    Manage schema-3 bounded-authority lifecycle state.
   start-work-next Print the next active start-work continuation directive.
   public-read   Read a public http(s) source with FetchAttempt/FetchVerdict JSON.
+  motion-runtime Pre-warm (install [--audio] [--word-timing]) or report (status) the
+                lit-typographic-motion runtime cache. Run it outside a sandboxed session.
   update        Reinstall this package version and refresh the Claude plugin registry.
   uninstall     Remove LitClaude-managed install state.
 
@@ -86,6 +106,8 @@ Install options:
                 output style) and run without prompts. Model selection stays
                 host-owned: Claude Code picks its own models, so the installer
                 never asks for a model or reasoning effort.
+
+Typographic-motion engine adapted from mexicat/pdoom-video (MIT, Giacomo Magnanini), commit \`ca251e3\`.
 `;
 
 const parseArgs = (argv) => {
@@ -1051,8 +1073,18 @@ const verifyInstalledPayload = ({ home, litClaudeHome, targetPlugin }) => {
   }
 };
 
-const preflightInstallOwnership = () => {
+const preflightInstallOwnership = ({ preserveModifiedSkill = false } = {}) => {
   const home = claudeHome(), lit = litHome();
+  assertInstallPath(home, installedPluginsPath(home), { file: true });
+  const registry = readInstalledPlugins(home);
+  const registration = preserveModifiedSkill
+    ? registeredPluginInstallation({
+      registry, pluginKey, pluginParent: dirname(claudePluginRoot(home)), home, version,
+    })
+    : null;
+  const activeVersion = registration?.version ?? version;
+  const activePlugin = registration?.installPath ?? claudePluginRoot(home);
+  let marketplaceVersion = null;
   const trees = [
     [home, claudePluginRoot(home), "plugin"],
     [lit, marketplaceRoot(lit), "marketplace"],
@@ -1060,18 +1092,41 @@ const preflightInstallOwnership = () => {
   ];
   for (const [boundary, path, kind] of trees) {
     assertInstallPath(boundary, path);
-    assertOwnedTree(path, kind, version, { allowPreviousVersion: kind === "marketplace" });
+    if (!(preserveModifiedSkill && kind === "plugin" && path === activePlugin)) {
+      const ownedVersion = assertOwnedTree(path, kind, version, { allowPreviousVersion: kind === "marketplace" });
+      if (kind === "marketplace") marketplaceVersion = ownedVersion;
+    }
   }
-  assertCurrentPointer(lit, currentRoot(lit), versionRoot(lit), version);
+  if (registration && activeVersion !== version) {
+    const activeCompatibility = join(lit, "litclaude-ai", activeVersion);
+    assertInstallPath(lit, activeCompatibility);
+    assertOwnedTree(activeCompatibility, "compatibility", activeVersion, { requirePresent: true });
+  }
+  const preservation = preserveModifiedSkill
+    ? planModifiedLegacySkill({
+      activePlugin,
+      marketplacePlugin: marketplacePluginPath(lit),
+      compatibilityPlugin: pluginPathForRoot(join(lit, "litclaude-ai", activeVersion)),
+      version,
+      installedVersion: activeVersion,
+      marketplaceVersion,
+    })
+    : null;
+  if (preserveModifiedSkill && !preservation) {
+    assertOwnedTree(claudePluginRoot(home), "plugin", version);
+  }
+  assertCurrentPointer(lit, currentRoot(lit), versionRoot(lit), version, { expectedVersion: registration?.version });
   for (const path of [claudeSettingsPath(home), installedPluginsPath(home), knownMarketplacesPath(home)]) {
     assertInstallPath(home, path, { file: true });
   }
   assertOwnedRegistrations({
-    registry: readInstalledPlugins(home), settings: readClaudeSettings(home), marketplaces: readKnownMarketplaces(home),
+    registry, settings: readClaudeSettings(home), marketplaces: readKnownMarketplaces(home),
     pluginKey, marketplaceName, marketplacePath: marketplaceRoot(lit), pluginParent: dirname(claudePluginRoot(home)), home, version,
+    modifiedPluginRoot: preservation?.activePlugin, modifiedPluginVersion: preservation?.version,
   });
   assertInstallPath(lit, dirname(updateNotifierCachePath(lit)));
   assertInstallPath(lit, updateNotifierCachePath(lit), { file: true });
+  return preservation;
 };
 
 const install = async ({ dryRun, rest }) => {
@@ -1102,6 +1157,7 @@ const install = async ({ dryRun, rest }) => {
       : permissionModes.has(existingLitClaude.permissionMode) ? "preserved" : "default";
     process.stdout.write(`Would mutate global Claude settings permissions.allow/deny: ${permissionMode} (${permissionSource})\n`);
     process.stdout.write(`Permission profile: ${permissionProfile(permissionMode).description}\n`);
+    process.stdout.write("Would pre-warm the lit-typographic-motion runtime: litclaude-ai motion-runtime install\n");
     process.stdout.write("Launch with: claude\n");
     return;
   }
@@ -1116,7 +1172,8 @@ const install = async ({ dryRun, rest }) => {
   const outputStyleChoice = assumeYes
     ? normalizeOutputStyle(process.env.LITCLAUDE_OUTPUT_STYLE ?? existingOutputStyle)
     : await chooseOutputStyle(existingOutputStyle);
-  preflightInstallOwnership();
+  const preservation = preflightInstallOwnership({ preserveModifiedSkill: true });
+  const preservedPath = preserveModifiedLegacySkill(preservation, litClaudeHome);
   const targetCompatibility = versionRoot(litClaudeHome);
   migrateLegacyVendorPaths(targetPlugin, targetPlugin, "plugin", version);
   migrateLegacyVendorPaths(targetMarketplace, marketplacePluginPath(litClaudeHome), "marketplace", version);
@@ -1208,7 +1265,9 @@ const install = async ({ dryRun, rest }) => {
   process.stdout.write(`Plugin path: ${intendedPluginPath(home)}\n`);
   process.stdout.write(hudManaged ? `HUD: LitClaude statusLine installed (${hudAccent})\n` : "HUD: user statusLine setting preserved\n");
   process.stdout.write(`Global Claude settings permissions.allow/deny: ${permissionMode} — ${permissionProfile(permissionMode).description}\n`);
+  process.stdout.write(`${prewarmMotionRuntime()}\n`);
   process.stdout.write("Launch with: claude\n");
+  if (preservedPath) process.stderr.write(`INSTALL_WARNING: PRESERVED_MODIFIED_SKILL lit-korean at ${preservedPath}\n`);
 };
 
 const doctor = ({ dryRun }) => {
@@ -1222,7 +1281,10 @@ const doctor = ({ dryRun }) => {
     process.stdout.write("Would check global Claude settings permissions.allow/deny and LitClaude ownership-safe removal metadata\n");
     process.stdout.write(`Would inspect automatic-update receipt/journal under: ${join(automaticUpdateRoot(litHome()), "receipt.json")}\n`);
     process.stdout.write(`Would run: node ${join(pluginPath, "bin", "litclaude-scientific-visualization-doctor.js")}\n`);
+    process.stdout.write(`Would report: node ${join(pluginPath, "lib", "office-runtime.mjs")} status\n`);
+    process.stdout.write(`Would report: node ${join(pluginPath, "skills", "lit-typographic-motion", "scripts", "motion-doctor.mjs")} (Chrome, ffmpeg, WebGL2 renderer, software-GL warning, motion pre-warm)\n`);
     process.stdout.write("Would verify exact canonical frontend corpus bytes, legal companions, no extras, and three canonical runtime closures\n");
+    process.stdout.write(`${jevStatusLine(process.env)}\n`);
     return;
   }
 
@@ -1303,6 +1365,21 @@ const doctor = ({ dryRun }) => {
   }
   process.stdout.write("BUNDLED_SKILLS_PAYLOAD_PASS\n");
 
+  // lit-pptx and lit-docx install their pinned runtime on first use; the doctor reports
+  // readiness and the optional host tools but never installs and never fails on them.
+  const officeRuntime = spawnSync(process.execPath, [join(pluginPath, "lib", "office-runtime.mjs"), "status"], { encoding: "utf8" });
+  for (const line of `${officeRuntime.stdout || officeRuntime.stderr || ""}`.trim().split("\n").filter(Boolean)) {
+    process.stdout.write(`OFFICE_RUNTIME: ${line}\n`);
+  }
+  process.stdout.write(`${jevStatusLine(process.env)}\n`);
+
+  // lit-typographic-motion: the five readiness probes, every run. Read-only and never fatal; a
+  // missing pre-warm names the command that fixes it.
+  const motionDoctor = spawnSync(process.execPath, [join(pluginPath, "skills", "lit-typographic-motion", "scripts", "motion-doctor.mjs")], { encoding: "utf8", timeout: 120000 });
+  const motionLines = `${motionDoctor.stdout || ""}`.trim().split("\n").filter(Boolean);
+  if (motionLines.length) for (const line of motionLines) process.stdout.write(`${line}\n`);
+  else process.stdout.write(`MOTION_DOCTOR_WARNING: probes did not run (${`${motionDoctor.stderr || motionDoctor.error?.message || "no output"}`.trim().split("\n")[0]})\n`);
+
   const claude = spawnSync("claude", ["--version"], { encoding: "utf8" });
   if (claude.error) {
     process.stdout.write("CLAUDE_WARNING: claude executable not found in PATH\n");
@@ -1483,7 +1560,7 @@ const main = async () => {
   }
 
   if (!parsed.dryRun && ["install", "update", "uninstall"].includes(command)) {
-    preflightInstallOwnership();
+    preflightInstallOwnership({ preserveModifiedSkill: ["install", "update"].includes(parsed.command) });
   }
   const automaticUpdate = runEligibleAutomaticUpdate(parsed);
   if (automaticUpdate.status === "rollback-failed") {
@@ -1532,6 +1609,11 @@ const main = async () => {
     case "start-work":
       process.exit(runStartWorkCli(parsed.rest, undefined, process.cwd()));
       break;
+    case "motion-runtime": {
+      const { main: motionRuntime } = await import(pathToFileURL(join(motionSkillScripts, "motion-runtime.mjs")).href);
+      process.exit(await motionRuntime(parsed.rest));
+      break;
+    }
     case "uninstall":
       uninstall(parsed);
       break;

package/docs/agents.md

@@ -35,13 +35,16 @@ The planner is deliberately constrained because the safest Claude Code retrofit
 keeps planning separate from mutation. Executor and QA agents can act only
 inside the plan and evidence contract.
 
-## Korean AI Slop Remover Routing
-
-`/litclaude:lit-korean` activates
-`Skill(lit-korean)`. Fast mode is the default for short, low-risk
-Korean prose polish and does not require spawned agents. Strict mode uses the
-local agent inventory above when the user asks for strict review, redo, long
-input, fidelity-sensitive text, or a documented before/after audit.
+## Lit Humanizer and Korean Review Routing
+
+`/litclaude:lit-humanizer` activates `Skill(lit-humanizer)` for reader-facing
+prose edits and artifact review. The one-release `/litclaude:lit-korean` and
+`/litclaude:korean-ai-slop-remover` redirects, plus the bare
+`text-naturalization` alias, also route to `lit-humanizer`. Fast mode is the
+default for short, low-risk Korean prose polish and does not require spawned
+agents. Strict mode uses the local agent inventory above when the user asks for
+strict review, redo, long input, fidelity-sensitive text, or a documented
+before/after audit.
 
 The strict order is analyzer, editor, parallel meaning and flow reviews, then
 orchestrator decision. The safety boundary is meaning-first: editable prose is

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