dsh-embedded-workbench 0.8.12 → 0.9.1

package/src/client.js

@@ -0,0 +1,214 @@
+/**
+ * embedded-workbench — browser half: the gate-injection switch on the dsh Web
+ * client's Plugins page.
+ *
+ * The Plugins page (`@deepseek-ai/dsh-client-ui-plugin-manager`) owns the
+ * sidebar **Plugins** entry and declares the slots a bundle's own configuration
+ * registers into. This module contributes one `plugins.bundle.config` entry,
+ * keyed by this package's npm name, so the switch renders on
+ * embedded-workbench's own page between its description and its rows.
+ *
+ * Why the switch writes through `configForms` rather than reaching for the
+ * profile file: dsh's settings service exposes only the Config fields declared
+ * `.volatile()`, and it rejects a write to any other path. `enabled` is such a
+ * field (see `src/index.ts`), so flipping the switch is an ordinary
+ * revision-fenced settings write that the running Host picks up in place — the
+ * injection there re-reads the reference on every model step.
+ *
+ * Shape: this is a prebuilt module-system bundle, not a source module. It calls
+ * `window.__ModuleLoader__.load({ id, factory })` with this package's resolved
+ * npm name, and `factory` returns the cordis plugin face. Only the client
+ * baseline is requested (`react` and
+ * `@deepseek-ai/dsh-client-ui-primitives`); every other capability arrives
+ * through cordis `inject`. `scripts/build-client.mjs` publishes this file
+ * verbatim as `lib/client.js`.
+ *
+ * @module dsh-embedded-workbench/client
+ */
+
+window.__ModuleLoader__.load({
+  id: 'dsh-embedded-workbench',
+  factory: (require) => {
+    const React = require('react')
+    const { Button, Switch } = require('@deepseek-ai/dsh-client-ui-primitives')
+
+    /** Settings namespace: the Loader entry id this bundle's patch declares. */
+    const NS = 'embedded-workbench'
+    /** `plugins.bundle.config` key: the bundle's npm package name. */
+    const PACKAGE = 'dsh-embedded-workbench'
+    /** This page's dictionary namespace. */
+    const LOCALE_NS = 'embedded-workbench.plugins'
+    /** The Config field the switch writes inside the namespace's section. */
+    const FIELD = 'enabled'
+
+    /** English copy. */
+    const en = {
+      title: 'Gate injection',
+      label: 'Inject the gate text',
+      hint: 'Folds the Plan Verification Gate and the context-budget rule into the first model step of every session. Turning it off leaves all eight skills registered — only the injected text is dropped.',
+      overridden: 'Overridden',
+      reset: 'Reset to default',
+      readOnly: 'This deployment stores settings read-only.',
+      unavailable: 'This plugin is not loaded, so it cannot be configured right now.',
+      saveFailed: 'The deployment did not accept that value; the switch shows what is stored.',
+    }
+    /** Simplified Chinese copy. */
+    const zh = {
+      title: 'Gate 注入',
+      label: '注入 gate 文本',
+      hint: '把 Plan Verification Gate 与上下文预算规则折进每个会话的第一个模型步。关掉后 8 个技能仍然注册，只是不再注入那段提示文本。',
+      overridden: '已覆盖',
+      reset: '恢复默认',
+      readOnly: '本部署的设置为只读。',
+      unavailable: '该插件当前未加载，暂时无法配置。',
+      saveFailed: '本部署没有接受这个值，开关显示的是已存下的状态。',
+    }
+
+    /** Required cordis services. */
+    const inject = ['slots', 'locale', 'configForms']
+
+    const GROUP = { display: 'flex', flexDirection: 'column', gap: '8px' }
+    const TITLE = { margin: 0, fontSize: '14px', fontWeight: '500', lineHeight: '22px' }
+    const ROW = { display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: '16px' }
+    const LABEL = { fontSize: '13px', lineHeight: '20px' }
+    const NOTE = { margin: 0, fontSize: '12px', lineHeight: '18px', color: 'var(--dsw-alias-label-tertiary)' }
+    const FAILED = { margin: 0, fontSize: '12px', lineHeight: '18px', color: 'var(--dsw-alias-state-error-primary)' }
+
+    /**
+     * Whether a settings-layer value carries this field, which is what marks it
+     * overridden: an override equal to the default is still an override.
+     * @param layer - the raw user layer the form snapshot carries.
+     * @returns whether the layer holds the field.
+     */
+    function carries(layer) {
+      return layer !== null && typeof layer === 'object' && Object.prototype.hasOwnProperty.call(layer, FIELD)
+    }
+
+    /**
+     * Render the gate-injection switch, or the note saying why it cannot render.
+     * @param props - the page's `t` seat, the bound form snapshot hook, and the write actions.
+     * @returns the body of this bundle's configuration section.
+     */
+    function InjectionCard(props) {
+      const t = props.t
+      const state = props.useInjectionForm((snapshot) => snapshot)
+      const [pending, setPending] = React.useState(false)
+      const [failed, setFailed] = React.useState(false)
+
+      /** Run one settings write and report a refusal or a transport failure. */
+      const write = (run) => {
+        setPending(true)
+        setFailed(false)
+        Promise.resolve(run()).then(
+          (accepted) => {
+            setPending(false)
+            setFailed(accepted === false)
+          },
+          () => {
+            setPending(false)
+            setFailed(true)
+          },
+        )
+      }
+
+      if (state.status !== 'ready') {
+        return React.createElement('p', { style: NOTE }, t('unavailable'))
+      }
+
+      const section = state.value !== null && typeof state.value === 'object' ? state.value : {}
+      // The schema default is `true`; only an explicit false means off.
+      const checked = section[FIELD] !== false
+      const overridden = carries(state.user)
+      const locked = state.writable !== true || pending
+
+      const children = [
+        React.createElement('h4', { key: 'title', style: TITLE }, t('title')),
+        React.createElement('div', { key: 'row', style: ROW }, [
+          React.createElement('span', { key: 'label', style: LABEL }, t('label')),
+          React.createElement(Switch, {
+            key: 'switch',
+            checked,
+            disabled: locked,
+            label: t('label'),
+            onChange: (next) => write(() => props.setEnabled(next)),
+          }),
+        ]),
+        React.createElement('p', { key: 'hint', style: NOTE }, state.writable === true ? t('hint') : t('readOnly')),
+      ]
+
+      if (overridden) {
+        children.push(
+          React.createElement('div', { key: 'overridden', style: ROW }, [
+            React.createElement('span', { key: 'badge', style: NOTE }, t('overridden')),
+            React.createElement(
+              Button,
+              {
+                key: 'reset',
+                variant: 'outline',
+                size: 'sm',
+                disabled: locked,
+                onClick: () => write(() => props.resetEnabled()),
+              },
+              t('reset'),
+            ),
+          ]),
+        )
+      }
+
+      if (failed) {
+        children.push(React.createElement('p', { key: 'failed', style: FAILED, role: 'alert' }, t('saveFailed')))
+      }
+
+      return React.createElement('div', { style: GROUP }, children)
+    }
+
+    /**
+     * Mount the switch while the Host serves embedded-workbench's settings
+     * namespace.
+     * @param ctx - the browser plugin context.
+     */
+    function apply(ctx) {
+      ctx.effect(() => ctx.locale.register(LOCALE_NS, { zh, en }), 'dsh-embedded-workbench: dictionaries')
+      // `whileServed` is the registration barrier that keeps this page alive only
+      // while the Host serves the namespace. Hosts predating it (measured: dsh
+      // 0.1.5-rc.3 and 0.1.6-alpha.2) have no live settings field to offer at all,
+      // so there is nothing to register — and calling it there would throw during
+      // this plugin's own activation, which the Web boot audit then reports as a
+      // failed client entry. Degrade to no page instead.
+      if (typeof ctx.configForms.whileServed !== 'function') return
+      // The page renders the section only for a bundle whose package name is in
+      // its configuration ledger, and the ledger follows this registration. The
+      // registration in turn waits for the namespace to be served, so a profile
+      // whose embedded-workbench row is switched off shows no trace of the
+      // switch.
+      ctx.effect(
+        () =>
+          ctx.configForms.whileServed([NS], () => {
+            const form = ctx.configForms.get(NS)
+            const source = {
+              getSnapshot: () => form.getSnapshot(),
+              subscribe: (listener) => form.subscribe(listener),
+            }
+            return ctx.slots.inject('plugins.bundle.config', () =>
+              ctx.slots.register(
+                {
+                  name: 'plugins.bundle.config',
+                  key: PACKAGE,
+                  locale: LOCALE_NS,
+                  inject: () => ({
+                    hooks: { injectionForm: source },
+                    setEnabled: (next) => form.set(FIELD, next),
+                    resetEnabled: () => form.unset(FIELD),
+                  }),
+                },
+                InjectionCard,
+              ),
+            )
+          }),
+        'dsh-embedded-workbench: gate-injection switch',
+      )
+    }
+
+    return { inject, apply }
+  },
+})

package/src/index.ts

@@ -1,12 +1,11 @@
 /**
  * embedded-workbench — DeepSeek Harness native plugin for the Embedded
- * Workbench toolbox. Injects the session-start gate text (1% Rule, Red
- * Flags, Plan Verification Gate, skills roster) into the first model step
- * of every agent session, mirroring the SessionStart hook the Claude Code
- * plugin installs. The 8 skills ship in this package's `skills/` directory
+ * Workbench toolbox. The 8 skills ship in this package's `skills/` directory
  * and are registered at apply time into dsh's `ctx.skills` registry through
  * the standard filesystem provider, so they appear in every session catalog
- * without a manual copy step.
+ * without a manual copy step. The plugin also folds a short gate text into the
+ * first model step of every agent session, mirroring the SessionStart hook the
+ * Claude Code plugin installs.
  *
  * Injection listens on agent/pre-step and appends the gate to the FIRST
  * model step that runs, once per session (guarded by the session's durable
@@ -17,17 +16,20 @@
  * reminders (skill catalog, AGENTS.md, gate plugins) simply defer this message
  * to the first step after their promotion, and the history guard re-injects it
  * there. The default gate text is the dsh-native adaptation of
- * `hooks/session-start-content.md`: behavior rules
- * (1% Rule / Red Flags / Plan Verification Gate) stay in sync, while
- * presentation is adapted to dsh's native skill catalog — no roster table
- * (the model sees skills in its catalog) and no install instructions (those
- * live in `.dsh/INSTALL.md`). Deployments override via Config.
+ * `hooks/session-start-content.md`: the behavior rules stay in sync (the Plan
+ * Verification Gate and the context-budget rule), while presentation is adapted
+ * to dsh's native skill catalog — no roster table (the model sees skills in its
+ * catalog) and no install instructions (those live in `.dsh/INSTALL.md`). The
+ * payload is deliberately small: it carries the verification gate and the
+ * budget rule, not the 1% Rule / Red Flags enforcement scaffolding, which
+ * measurably pushes capable models into rigid phases and unnecessary fan-out.
+ * Deployments override via Config.
  *
  * @module embedded-workbench-dsh
  */
 
 import { fileURLToPath } from 'node:url'
-import type { Context } from '@deepseek-ai/cordis'
+import type { Context, Volatile } from '@deepseek-ai/cordis'
 import z from '@deepseek-ai/schemastery'
 import { createUserMessage } from '@deepseek-ai/dsh-llm'
 import type { ContextFormed } from '@deepseek-ai/dsh-llm'
@@ -64,41 +66,77 @@ const GATE_PLUGIN_ID = 'embedded-workbench'
 const GATE_SOURCE_KIND: 'plugin:embedded-workbench' = 'plugin:embedded-workbench'
 
 const DEFAULT_GATE_CONTENT = `<EXTREMELY_IMPORTANT>
-Plugin embedded-workbench is active. You have embedded C/C++ firmware development skills — names and "Use when" triggers are in your skill catalog; load them with the skill tool. No custom agents in dsh: use the native subagent tooling for parallel work.
+Plugin embedded-workbench is active: embedded C/C++ firmware development skills are in your skill catalog. Load the one whose "Use when" matches before substantial work, with the skill tool.
 
-**1% Rule**: If there is even a 1% chance a skill applies to your task, invoke it before responding. If the skill turns out to be wrong for the situation, discard it and move on. The cost of loading a skill is trivial compared to the cost of a preventable mistake.
+**Plan Verification Gate**: before calling exit_plan_mode (or presenting a plan for approval), load the logicprobe skill — or the built-in fact-check skill when logicprobe is not installed — and append a "## Plan Verification" block to the plan. If you verify with neither, tell the user the plan is unverified before asking for approval; a silent skip is not an option. "This change is too small to check" and "I already read the code, the paths are right" are the two rationalizations this gate exists to catch.
 
-**Red Flags** — if you think any of these, STOP. You are rationalizing:
+**Context budget**: no token meter is visible to you, so never guess one. Act on what you can see — a pruned or spilled tool result means stop pulling it in whole, and a compaction checkpoint means move durable state into files. When a large step (many sources, a long sweep, several independent areas) shows no such signal, ask the user what to spend context on rather than deciding silently. If nobody can answer, take the reversible option and say so. When you do delegate, prefer \`subagent_fork\` over \`subagent\` if the sub-agent needs context you already built — its summary still lands here.
 
-| You think | Reality |
-|-----------|---------|
-| "This is just a quick fix" | Quick fixes break things. A 3-line design check costs 30 seconds. |
-| "I already understand this code" | You are looking at one file. The blast radius may span 5 modules. |
-| "The skill is overkill for this" | Simple things become complex. Check for skills. |
-| "Let me explore the codebase first" | Skills tell you HOW to explore. Check first. |
-| "I can just read the file directly" | Skills have patterns and pitfalls you will not discover by reading. |
-| "I remember this skill content" | Skills evolve. Always load the current version. |
-| "I've explored enough, time to exit plan mode" | The exit_plan_mode tool is the verification gate. Have you loaded the logicprobe skill — or, if it is not installed, the built-in fallback fact-check skill? Every plan must pass this gate before exit. |
-| "This plan is too simple for logicprobe" | logicprobe auto-classifies depth; the fallback fact-check verifies every claim regardless. You don't decide. |
-| "I already read the code, I know the file paths are correct" | Load the logicprobe skill or the fallback fact-check skill, verify each claim, append the "## Plan Verification" block. |
-
-**Plan Verification Gate**: Before calling exit_plan_mode (or presenting a plan for approval), load the logicprobe skill (a separate plugin) — or, if it is missing from your skill catalog, load the built-in fallback fact-check skill for claim-by-claim verification, tell the user that behavioral/model claims degrade to manual confirmation, and recommend installing logicprobe. If neither is loaded, inform the user "此计划未经核查，是否需要我先做事实核查？" Silent skip is not an option.
+To load the workflows and engineering policies behind these skills: load the embedded-workbench skill.
+</EXTREMELY_IMPORTANT>`
 
-To load workflows and engineering policies: load the embedded-workbench skill.
+/** A schemastery field that may or may not carry `.volatile()`. */
+interface LiveField {
+  volatile?: () => unknown
+}
 
-**Proactive features**: When you see state machines, protocol refactoring, behavioral claims ("always"/"never"), or multi-module tasks — suggest verification (logicprobe, or the built-in fact-check fallback if logicprobe is not installed), adversarial probing, or parallel subagents BEFORE the user asks. Most users do not know these exist.
-</EXTREMELY_IMPORTANT>`
+/**
+ * Declare a field as live where this host's schemastery can — `.volatile()`
+ * arrived in 3.18.3 — and leave it an ordinary field where it cannot.
+ *
+ * The fallback is load-bearing, not defensive padding. `Config` below is built
+ * while this module is still being evaluated, so an unconditional `.volatile()`
+ * on a host shipping schemastery 3.18.2 (measured: dsh 0.1.5-rc.2 and
+ * 0.1.5-rc.3) throws during import; the loader entry then fails and takes the
+ * WHOLE plugin tree — and the host's boot — down with it. Degrading costs only
+ * the Plugins-page switch, because the settings service projects nothing but
+ * fields under a `.volatile()` node; the skills and the gate injection are
+ * untouched. The returned schema keeps the plain field's static type; the
+ * `Config` interface below carries the union the host actually hands over.
+ */
+function live<T>(field: T): T {
+  const probe = field as T & LiveField
+  return typeof probe.volatile === 'function' ? (probe.volatile() as T) : field
+}
 
 export interface Config {
-  enabled: boolean
+  /**
+   * The injection switch the Web client's Plugins page edits live: a `Volatile`
+   * reference on a host whose schemastery supports one, an ordinary boolean on a
+   * host that predates `.volatile()`. Read it through {@link injectionEnabled},
+   * which accepts both shapes.
+   */
+  enabled: Volatile<boolean> | boolean
   gateContent: string
 }
 
 export const Config = z.object({
-  enabled: z.boolean().default(true),
+  // Live so the Web Plugins page can flip the gate injection inside a running
+  // session: dsh's settings service projects ONLY fields under a `.volatile()`
+  // node and rejects writes to every other path. The price is that the injection
+  // reads the reference per step instead of deciding once at mount, which is also
+  // what lets a toggle take effect without remounting the row.
+  //
+  // On by default, but deliberately small: the payload carries the verification
+  // gate and the context-budget rule only, so leaving it on costs a few hundred
+  // tokens once per session rather than the ~900 of the previous payload.
+  enabled: live(z.boolean().default(true)),
+  // Not volatile, deliberately: the settings projection feeds a GUI form, and a
+  // multi-kilobyte text field does not belong in one. Override it in the
+  // profile's `cordis.patch.yml` row instead.
   gateContent: z.string().default(DEFAULT_GATE_CONTENT),
 })
 
+/**
+ * Read the injection switch as a boolean, whichever shape this host produced.
+ * @param config - the resolved plugin configuration.
+ * @returns whether the gate may be injected.
+ */
+function injectionEnabled(config: Config): boolean {
+  const value = config.enabled
+  return typeof value === 'boolean' ? value : value.get()
+}
+
 function gateMessage(text: string): UserMessage {
   return createUserMessage({
     content: [{ type: 'text', text }],
@@ -143,7 +181,7 @@ function inspectProvider(config: Config): HostCordisInspectProviderRegistration
   return {
     manifest: {
       id: 'embedded-workbench',
-      description: 'Session-start gate injection for the Embedded Workbench toolbox — folds the 1% Rule / Red Flags / Plan Verification Gate text into the first model step of every agent session.',
+      description: 'Session-start gate injection for the Embedded Workbench toolbox — folds the Plan Verification Gate and the context-budget rule into the first model step of every agent session.',
       methods: [
         {
           name: 'status',
@@ -169,7 +207,7 @@ function inspectProvider(config: Config): HostCordisInspectProviderRegistration
     query: async (method) => {
       if (method === 'status') {
         return {
-          enabled: config.enabled,
+          enabled: injectionEnabled(config),
           gateContentLength: config.gateContent.length,
         }
       }
@@ -211,7 +249,12 @@ export function apply(ctx: Context, config: Config): void {
       customSkillDirs: [SKILLS_DIR],
     })
   })
-  if (!config.enabled) return
+  // Injection listens unconditionally, including while the switch is off: the
+  // switch is volatile, so `apply` runs once and the value behind it can turn on
+  // later from the Web Plugins page. Returning early on a false value here would
+  // freeze that decision for the lifetime of the mount, and turning the switch
+  // back on could never take effect without a profile restart.
+  //
   // Inject the gate once per session on the FIRST model step that runs,
   // instead of at session-start: session-start injection lands in the agent's
   // inbox, which a blank-session preset switch (agentPreset.select ->
@@ -227,6 +270,7 @@ export function apply(ctx: Context, config: Config): void {
     const decision = await next()
     if (decision.kind === 'reject') return decision
     registerProvider()
+    if (!injectionEnabled(config)) return decision
     if (gateInHistory(agent.session)) return decision
     return {
       kind: 'enter',