@dsh-jev/effort 0.1.0

package/README.md

@@ -0,0 +1,46 @@
+# @dsh-jev/effort
+
+dsh Web-only plugin: [jev System One](https://typesafe.ai) lowers the
+reasoning effort to `low` for simple turns, with a dismissible composer hint.
+
+Modeled on the mature `dsh-quote-followup` plugin pattern:
+
+- **Two halves.** The host face (`lib/index.js`) hooks the `agent/request`
+  waterfall: before a turn's first request it asks jev `choice(keep|lower)`
+  with the newest user text as context; a "lower" pick rewrites
+  `reasoningEffort` to `low` (configurable via `targetEffort`). The browser
+  face (`lib/client.js`, mounted via the package's `dsh.client`
+  `platform: web` declaration) renders a lightweight, dismissible hint above
+  the composer explaining the behavior.
+- **Never touches provider/model.** Only `reasoningEffort` is rewritten —
+  route selection is deliberately out of scope (that's `@dsh-jev/router`'s
+  job, with its own registration gates). No LLM route is ever registered.
+- **Silent fallback.** jev unreachable / timeout / non-2xx → the resolved
+  config is returned unchanged (original effort kept), logged only. The
+  listener never throws into the request path.
+- **Composer hint is dismissible** (persisted in `localStorage`), localized
+  via the injected DSH `locale` service with English fallback, and rendered
+  as a plain sibling DOM node — no contenteditable or Lexical internals are
+  touched (the two known contenteditable/paste footguns do not apply).
+- **Hot-swap hardening.** Versioned global state + element ownership
+  (`data-dsh-jev-effort-version`) so an old listener from a long-lived tab
+  cannot tear down the new UI after a client bundle swap; old hosts without
+  `locale` degrade to English copy, without a composer the hint stays hidden.
+
+Known seam limitation (v1): the composer hint is informational — the dynamic
+jev verdict lives host-side (visible in stdout logs), because the browser
+must not hold the jev API key.
+
+## Install into the Web profile
+
+```sh
+dsh plugin --profile web add dsh-jev-effort  # once published
+```
+
+or via the bundle patch in `cordis.patch.yml` (`- insert: - id: jev-effort`).
+
+## Development
+
+```sh
+pnpm --filter @dsh-jev/effort test   # syntax checks + 11 vitest cases
+```

package/cordis.patch.yml

@@ -0,0 +1,11 @@
+# dsh-jev-effort Web bundle patch.
+# The host row carries the effort-lowering request waterfall; the browser
+# client entry (mounted via dsh.client) renders the composer hint.
+
+- insert:
+    - id: jev-effort
+      name: dsh-jev-effort
+      config:
+        enabled: true
+        # targetEffort: low
+        # endpoint / apiKey / timeoutMs are honored via @dsh-jev/core env defaults

package/lib/client.js

@@ -0,0 +1,157 @@
+/**
+ * dsh-jev-effort — browser half (Web face).
+ *
+ * A lightweight, dismissible hint above the composer telling the user that
+ * simple turns are automatically lowered to `low` reasoning effort by jev
+ * (the host half does the actual judgment at `agent/request`; the browser
+ * cannot hold the API key). Dismissal persists in localStorage.
+ *
+ * Follows the dsh-quote-followup hardening pattern (see ~/.config/dsh/AGENTS.md):
+ *  1. never touches contenteditable internals — the hint is a sibling DOM node;
+ *  2. no synthetic clipboard / paste commands needed at all;
+ *  3. versioned global state + element ownership survive client hot-swaps;
+ *  4. old hosts degrade silently (no locale → English copy, no composer → hidden).
+ *
+ * @module dsh-jev-effort/client
+ */
+window.__ModuleLoader__.load({
+	id: "dsh-jev-effort",
+	factory: () => {
+		const exports = {};
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		const CLIENT_VERSION = "0.1.0";
+		const HINT_ID = "dsh-jev-effort-hint";
+		const OWNERSHIP_ATTR = "data-dsh-jev-effort-version";
+		const DISMISS_KEY = "dsh-jev-effort.hint.dismissed";
+		const COMPOSER_CONTAINER_SELECTORS = [
+			'[data-slot="conversation.composer"]',
+			"[data-composer-card]",
+			'[data-input-scroll]'
+		];
+		const LOCALE_NS = "jev-effort";
+		const LOCALE_DICT = {
+			zh: {
+				"hint.text": "⚡ jev：简单问题发送时将自动降低为 low 推理档",
+				"hint.dismiss": "知道了"
+			},
+			en: {
+				"hint.text": "⚡ jev: simple turns are automatically lowered to low reasoning effort",
+				"hint.dismiss": "Got it"
+			}
+		};
+		const fallbackT = (key) => LOCALE_DICT.en[key] ?? key;
+		let currentT = fallbackT;
+		const isDismissed = () => {
+			try {
+				return globalThis.localStorage?.getItem(DISMISS_KEY) === "1";
+			} catch {
+				return false;
+			}
+		};
+		const findComposerContainer = () => {
+			for (const selector of COMPOSER_CONTAINER_SELECTORS) {
+				const element = document.querySelector(selector);
+				if (element !== null)
+					return element;
+			}
+			return null;
+		};
+		const styleOnce = (() => {
+			let done = false;
+			return () => {
+				if (done)
+					return;
+				done = true;
+				const style = document.createElement("style");
+				style.id = "dsh-jev-effort-style";
+				style.textContent = `#${HINT_ID}{display:flex;align-items:center;gap:8px;margin:0 0 6px;padding:4px 10px;font-size:12px;line-height:1.4;border-radius:8px;background:color-mix(in srgb, var(--ds-primary, #4c6ef5) 8%, transparent);color:inherit;opacity:.85}
+#${HINT_ID} button{margin-left:auto;border:none;background:transparent;color:inherit;font:inherit;cursor:pointer;opacity:.7;text-decoration:underline;padding:0}`;
+				document.head.append(style);
+			};
+		})();
+		/**
+		 * (Re)create the hint bar. Ownership: only the state whose version matches
+		 * the live element's stamped version may remove it — a stale hot-swapped
+		 * listener cannot tear down the new UI.
+		 */
+		const renderHint = () => {
+			if (isDismissed())
+				return;
+			const container = findComposerContainer();
+			if (container === null)
+				return;
+			styleOnce();
+			const existing = document.getElementById(HINT_ID);
+			if (existing?.getAttribute(OWNERSHIP_ATTR) === CLIENT_VERSION)
+				return;
+			existing?.remove();
+			const bar = document.createElement("div");
+			bar.id = HINT_ID;
+			bar.setAttribute(OWNERSHIP_ATTR, CLIENT_VERSION);
+			const text = document.createElement("span");
+			text.textContent = currentT("hint.text");
+			const dismiss = document.createElement("button");
+			dismiss.type = "button";
+			dismiss.textContent = currentT("hint.dismiss");
+			dismiss.addEventListener("click", () => {
+				try {
+					globalThis.localStorage?.setItem(DISMISS_KEY, "1");
+				} catch {}
+				if (bar.getAttribute(OWNERSHIP_ATTR) === CLIENT_VERSION)
+					bar.remove();
+			});
+			bar.append(text, dismiss);
+			container.parentElement?.insertBefore(bar, container);
+		};
+		const STATE = Symbol.for("dsh-jev-effort.state");
+		function apply(ctx) {
+			const previous = globalThis[STATE];
+			if (previous?.version === CLIENT_VERSION)
+				return;
+			if (typeof previous?.dispose === "function")
+				previous.dispose();
+			let unregisterLocale = null;
+			let observer = null;
+			let disposed = false;
+			let state;
+			try {
+				const locale = typeof ctx?.get === "function" ? ctx.get("locale") : null;
+				if (typeof locale?.register === "function" && typeof locale?.bind === "function") {
+					unregisterLocale = locale.register(LOCALE_NS, LOCALE_DICT);
+					currentT = locale.bind(LOCALE_NS);
+				} else {
+					currentT = fallbackT;
+				}
+			} catch {
+				currentT = fallbackT;
+			}
+			renderHint();
+			// The composer mounts asynchronously; watch for it and late layouts.
+			try {
+				observer = new MutationObserver(() => renderHint());
+				observer.observe(document.body, { childList: true, subtree: true });
+			} catch {}
+			const cleanup = () => {
+				if (disposed)
+					return;
+				disposed = true;
+				observer?.disconnect();
+				if (typeof unregisterLocale === "function")
+					unregisterLocale();
+				currentT = fallbackT;
+				const bar = document.getElementById(HINT_ID);
+				if (bar?.getAttribute(OWNERSHIP_ATTR) === CLIENT_VERSION)
+					bar.remove();
+				if (globalThis[STATE] === state)
+					delete globalThis[STATE];
+			};
+			state = { version: CLIENT_VERSION, dispose: cleanup };
+			globalThis[STATE] = state;
+			if (ctx !== undefined && typeof ctx.effect === "function")
+				ctx.effect(() => cleanup, "dsh-jev-effort: composer hint");
+		}
+		exports.inject = ["locale"];
+		exports.apply = apply;
+		return exports;
+	}
+});

package/lib/index.js

@@ -0,0 +1,113 @@
+/**
+ * dsh-jev-effort — host face.
+ *
+ * Web-only feature (the bundle patch is only inserted into the Web profile),
+ * but this host entry is the half that can actually see the request: on the
+ * `agent/request` waterfall it asks jev System One whether the current turn
+ * is simple enough to lower `reasoningEffort` to `low`. It NEVER touches
+ * provider/model — route selection belongs elsewhere (dsh-jev-router does
+ * that job deliberately, with its own gates) — and on any jev failure it
+ * silently returns the resolved config unchanged (original effort kept).
+ *
+ * The browser half (lib/client.js) renders the dismissible composer hint.
+ */
+
+import { createJevClient } from '@dsh-jev/core';
+
+/** Rank: lower number = more effort. Unknown efforts never get lowered. */
+export const EFFORT_RANK = { max: 0, high: 1, medium: 2, low: 3 };
+
+export function canLowerEffort(current, target = 'low') {
+  const a = EFFORT_RANK[current];
+  const b = EFFORT_RANK[target];
+  if (a === undefined || b === undefined) return false;
+  return b > a;
+}
+
+/** Pure decision used by the request listener (unit-tested directly). */
+export function decideEffort(
+  outcome /* JevOutcome<ChoiceAnswer> */,
+  resolved /* frozen LlmCallConfig */,
+  target = 'low'
+) {
+  if (!outcome.ok) {
+    return { effort: resolved.reasoningEffort, lowered: false, reason: `jev degraded (${outcome.error ?? 'unknown'}) — keeping effort` };
+  }
+  if (outcome.value.picked !== 'lower') {
+    return { effort: resolved.reasoningEffort, lowered: false, reason: 'jev says keep' };
+  }
+  if (!canLowerEffort(resolved.reasoningEffort, target)) {
+    return { effort: resolved.reasoningEffort, lowered: false, reason: `effort ${String(resolved.reasoningEffort)} not lowerable to ${target}` };
+  }
+  return { effort: target, lowered: true, reason: 'ok' };
+}
+
+export const name = 'jev-effort';
+export const inject = [];
+
+export function apply(ctx, config = {}) {
+  const enabled = config.enabled !== false;
+  const target = config.targetEffort ?? 'low';
+  const log = config.log ?? (() => {});
+  const jev = createJevClient({
+    ...(config.endpoint !== undefined ? { endpoint: config.endpoint } : {}),
+    ...(config.apiKey !== undefined ? { apiKey: config.apiKey } : {}),
+    ...(config.timeoutMs !== undefined ? { timeoutMs: config.timeoutMs } : {}),
+    ...(config.fetchImpl !== undefined ? { fetchImpl: config.fetchImpl } : {}),
+  });
+
+  /** Newest user text per agent per turn, captured at pre-step. */
+  const turnText = new WeakMap();
+
+  ctx.on('agent/pre-step', async (payload, next) => {
+    const decision = await next();
+    const perTurn = turnText.get(payload.agent) ?? new Map();
+    perTurn.set(payload.turn, latestUserText(payload.messages));
+    turnText.set(payload.agent, perTurn);
+    return decision;
+  });
+
+  ctx.on('agent/request', async (payload, next) => {
+    const resolved = await next();
+    if (!enabled) return resolved;
+    let outcome;
+    try {
+      const text = turnText.get(payload.agent)?.get(payload.turn) ?? '';
+      outcome = await jev.choice(
+        {
+          question:
+            'Should this assistant turn run with reduced reasoning effort? ' +
+            'Answer "lower" only for simple turns (short factual Q&A, formatting, chit-chat) ' +
+            'where deep reasoning adds latency without value. Otherwise answer "keep".',
+          options: ['keep', 'lower'],
+          context: text ? { userTurn: text } : {},
+        },
+        { pickedIndex: 0, picked: 'keep' } // degraded outcomes keep the original effort
+      );
+    } catch {
+      return resolved; // defensive: JevClient never throws, but never break a request
+    }
+    const { effort, lowered, reason } = decideEffort(outcome, resolved, target);
+    if (lowered) {
+      log(`[dsh-jev-effort] turn=${payload.turn} step=${payload.step} ${String(resolved.reasoningEffort)} → ${effort} (jev)`);
+      return { ...resolved, reasoningEffort: effort };
+    }
+    log(`[dsh-jev-effort] turn=${payload.turn} step=${payload.step} keep (${reason})`);
+    return resolved;
+  });
+}
+
+/** Concatenate the newest user message's text blocks, bounded for context. */
+export function latestUserText(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const blocks = messages[i]?.content;
+    if (!Array.isArray(blocks)) continue;
+    const text = blocks
+      .filter((b) => b?.type === 'text' && typeof b.text === 'string')
+      .map((b) => b.text)
+      .join('\n')
+      .trim();
+    if (text) return text.slice(0, 4000);
+  }
+  return '';
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@dsh-jev/effort",
+  "version": "0.1.0",
+  "description": "dsh Web-only plugin: jev System One lowers reasoning effort to low for simple turns, with a dismissible composer hint",
+  "keywords": ["dsh", "dsh-plugin", "deepseek-harness", "web", "jev"],
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": ["lib", "cordis.patch.yml", "README.md"],
+  "scripts": {
+    "test": "node --check lib/index.js && node --check lib/client.js && vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@dsh-jev/core": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dsh": {
+    "engines": {
+      "dsh": ">=0.1.2-rc.1"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": ["locale"],
+      "platform": "web"
+    }
+  },
+  "license": "MIT"
+}