dsh-logicprobe 0.6.8 → 0.7.1

package/src/index.ts

@@ -26,7 +26,7 @@
  */
 
 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'
@@ -90,18 +90,63 @@ Plugin logicprobe is active. Documents are not truth — code is. Verify every v
 **Proactive suggestion**: When a user asks code-level behavioral questions — "could this state machine deadlock", "is this retry limit safe", "check this timing sequence for bugs", "is this migration non-breaking", "does this copy cover all required fields" — suggest logicprobe as an optional verification pass (do not auto-escalate).
 </EXTREMELY_IMPORTANT>`
 
+/** A schemastery field that may or may not carry `.volatile()`. */
+interface LiveField {
+  volatile?: () => unknown
+}
+
+/**
+ * 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; skills, tools 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
   interaction: InteractionMode
 }
 
 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.
+  enabled: live(z.boolean().default(true)),
   gateContent: z.string().default(DEFAULT_GATE_CONTENT),
   interaction: z.union(['ask', 'auto', 'follow-approval']).default('follow-approval'),
 })
 
+/**
+ * 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 }],
@@ -227,7 +272,7 @@ function inspectProvider(config: Config, isToolRegistered: () => boolean, isData
     query: async (method) => {
       if (method === 'status') {
         return {
-          enabled: config.enabled,
+          enabled: injectionEnabled(config),
           gateContentLength: config.gateContent.length,
           interaction: config.interaction,
           toolRegistered: isToolRegistered(),
@@ -324,7 +369,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 ->
@@ -340,6 +390,7 @@ export function apply(ctx: Context, config: Config): void {
     const decision = await next()
     if (decision.kind === 'reject') return decision
     registerIntegrations()
+    if (!injectionEnabled(config)) return decision
     if (gateInHistory(agent.session)) return decision
     return {
       kind: 'enter',

package/src/tool.ts

@@ -1,61 +1,61 @@
-import { defineTool, type JsonValue } from '@deepseek-ai/dsh-tools'
-import { runVerification } from './engine.js'
-
-export const LOGICPROBE_VERIFY_TOOL_NAME = 'logicprobe_verify'
-
-/**
- * Model-visible DSH tool wrapping the bundled TypeScript verification engine.
- * The model passes a LogicModelV1 object; the engine validates it and returns
- * the 22-check report (S1-S8 structural, A1-A14), or a 26-check
- * report when beforeModel is supplied (D1 behavioral preservation, D2
- * invariant continuity, D3 regression delta, D4 deadlock/liveness regression).
- * This is the dsh-native replacement for hand-filling the Python template
- * shipped in the skill references.
- */
-export const logicProbeVerifyTool = defineTool({
-  name: LOGICPROBE_VERIFY_TOOL_NAME,
-  description:
-    'Run executable state-machine verification (logicprobe). Takes a LogicModelV1 object with schemaVersion=1, init, states ({id, terminal?}), transitions ({from, event, to, guard?, updates?, cost?}), variables?, invariants?, concurrentPairs?, boundaryChecks?, resourcePairs?, idempotentEvents?, narrative?. Guards are structured ({variable, op, value} | {all} | {any} | {not}); invariants support never-states, var-in-range, event-before-state, leads-to, sequence, atomicity, budget (transition cost defaults to 1; A12 checks every reachable path stays within the declared budget and reports the shortest over-budget counterexample), and probability (transition weight, default 1, makes the model a DTMC; A13 checks P(hit target) against the bound by value iteration). Variables support monotonic inc/dec. The optional narrative block carries natural-language descriptions of states (narrative.states), events (narrative.events), and (state, event) scenarios (narrative.scenarios: [{from, event, scenario}]); when present it must fully cover the model and is echoed in the report. Returns a report with S1-S8 structural checks and A1-A13 adversarial/probability probes including shortest counterexample paths. If beforeModel is provided, also runs D1-D4 before/after regression checks. See skills/logicprobe/references/dsh-model-schema.md.',
-  parameters: {
-    model: {
-      type: 'json',
-      required: true,
-      description: 'LogicModelV1 state machine model to verify.',
-    },
-    maxStates: {
-      type: 'integer',
-      description: 'Maximum runtime states to explore. Default 10000.',
-    },
-    maxPermutationEvents: {
-      type: 'integer',
-      description: 'Maximum event count for A3 order permutation. Default 5.',
-    },
-    beforeModel: {
-      type: 'json',
-      description: 'Optional BEFORE LogicModelV1 state machine model for refactoring/migration regression comparison.',
-    },
-    stateMapping: {
-      type: 'json',
-      description: 'Optional object mapping BEFORE state ids to AFTER state ids. Omit for identity mapping (same state names).',
-    },
-  },
-  output: {
-    schema: {
-      type: 'json',
-      description: 'logicprobe verification report with summary and per-check findings.',
-    },
-    render(_args, value) {
-      return [{ type: 'text' as const, text: JSON.stringify(value, null, 2) }]
-    },
-  },
-  timeoutMs: 10_000,
-  isConcurrencySafe: () => true,
-  async execute(args) {
-    return runVerification(args.model, {
-      maxStates: args.maxStates,
-      maxPermutationEvents: args.maxPermutationEvents,
-      beforeModel: args.beforeModel,
-      stateMapping: args.stateMapping as Record<string, string> | undefined,
-    }) as unknown as JsonValue
-  },
-})
+import { defineTool, type JsonValue } from '@deepseek-ai/dsh-tools'
+import { runVerification } from './engine.js'
+
+export const LOGICPROBE_VERIFY_TOOL_NAME = 'logicprobe_verify'
+
+/**
+ * Model-visible DSH tool wrapping the bundled TypeScript verification engine.
+ * The model passes a LogicModelV1 object; the engine validates it and returns
+ * the 22-check report (S1-S8 structural, A1-A14), or a 26-check
+ * report when beforeModel is supplied (D1 behavioral preservation, D2
+ * invariant continuity, D3 regression delta, D4 deadlock/liveness regression).
+ * This is the dsh-native replacement for hand-filling the Python template
+ * shipped in the skill references.
+ */
+export const logicProbeVerifyTool = defineTool({
+  name: LOGICPROBE_VERIFY_TOOL_NAME,
+  description:
+    'Run executable state-machine verification (logicprobe). Takes a LogicModelV1 object with schemaVersion=1, init, states ({id, terminal?}), transitions ({from, event, to, guard?, updates?, cost?}), variables?, invariants?, concurrentPairs?, boundaryChecks?, resourcePairs?, idempotentEvents?, narrative?. Guards are structured ({variable, op, value} | {all} | {any} | {not}); invariants support never-states, var-in-range ({variable, min?, max?, when?} — when scopes the range to a state ({state}) or a guard node, is evaluated on the post-state of every transition, leaves the initial state checked unconditionally, and is rejected on any other invariant kind), event-before-state, leads-to, sequence, atomicity, budget (transition cost defaults to 1; A12 checks every reachable path stays within the declared budget and reports the shortest over-budget counterexample), and probability (transition weight, default 1, makes the model a DTMC; A13 checks P(hit target) against the bound by value iteration). The schema is closed: an undeclared key on any model part (model, state, transition, update, variable, invariant, boundaryCheck, resourcePair, narrative, scenario) is a validation error, never ignored. Variables support monotonic inc/dec. The optional narrative block carries natural-language descriptions of states (narrative.states), events (narrative.events), and (state, event) scenarios (narrative.scenarios: [{from, event, scenario}]); when present it must fully cover the model and is echoed in the report. Returns a report with S1-S8 structural checks and A1-A13 adversarial/probability probes including shortest counterexample paths. If beforeModel is provided, also runs D1-D4 before/after regression checks. See skills/logicprobe/references/dsh-model-schema.md.',
+  parameters: {
+    model: {
+      type: 'json',
+      required: true,
+      description: 'LogicModelV1 state machine model to verify.',
+    },
+    maxStates: {
+      type: 'integer',
+      description: 'Maximum runtime states to explore. Default 10000.',
+    },
+    maxPermutationEvents: {
+      type: 'integer',
+      description: 'Maximum event count for A3 order permutation. Default 5.',
+    },
+    beforeModel: {
+      type: 'json',
+      description: 'Optional BEFORE LogicModelV1 state machine model for refactoring/migration regression comparison.',
+    },
+    stateMapping: {
+      type: 'json',
+      description: 'Optional object mapping BEFORE state ids to AFTER state ids. Omit for identity mapping (same state names).',
+    },
+  },
+  output: {
+    schema: {
+      type: 'json',
+      description: 'logicprobe verification report with summary and per-check findings.',
+    },
+    render(_args, value) {
+      return [{ type: 'text' as const, text: JSON.stringify(value, null, 2) }]
+    },
+  },
+  timeoutMs: 10_000,
+  isConcurrencySafe: () => true,
+  async execute(args) {
+    return runVerification(args.model, {
+      maxStates: args.maxStates,
+      maxPermutationEvents: args.maxPermutationEvents,
+      beforeModel: args.beforeModel,
+      stateMapping: args.stateMapping as Record<string, string> | undefined,
+    }) as unknown as JsonValue
+  },
+})