dsh-logicprobe 0.8.0 → 0.8.1

package/README.en-US.md

@@ -97,6 +97,14 @@ npx -p @deepseek-ai/dsh dsh plugin --profile web add dsh-logicprobe
 
 Restart the profile afterwards. `dsh --profile web --dump-config` must show the `id: logicprobe` row with `enabled: true`. More options (plain skill copy, project-level install) are in [`.dsh/INSTALL.md`](.dsh/INSTALL.md).
 
+pnpm 11 has a release-age gate. It holds back versions published less than a day ago (`minimumReleaseAge`, default 1440 minutes), and its default is non-strict, so a bare-name install **silently resolves to the previous version**. The profile then looks like the release never happened. To get the newest version within about 24 hours of a release, pin it:
+
+```bash
+dsh plugin --profile web add dsh-logicprobe@<version>
+```
+
+pnpm records that version in a `minimumReleaseAgeExclude` entry in the profile's `pnpm-workspace.yaml`. That entry is pnpm's documented escape hatch.
+
 > Package name note: the npm package is `dsh-logicprobe`, with no scope. In the web profile's `package.json`, both the dependency key and the `dsh.profile.bundles` entry must use that name. On a mismatch the dsh loader cannot find `node_modules/dsh-logicprobe` and the boot fails.
 
 ## UML Modelling and Review

package/README.md

@@ -95,6 +95,14 @@ npx -p @deepseek-ai/dsh dsh plugin --profile web add dsh-logicprobe
 
 装完重启 profile。运行 `dsh --profile web --dump-config` 应看到 `id: logicprobe` 且 `enabled: true`。更多方式（纯技能拷贝、项目级等）见 [`.dsh/INSTALL.md`](.dsh/INSTALL.md)。
 
+pnpm 11 有一个发布年龄闸门。它挡住发布不满一天的新版本（`minimumReleaseAge`，默认 1440 分钟），而且默认是非严格模式，所以裸名安装会**静默装到上一个版本**，profile 看起来像这次发版没发生。发版后约 24 小时内要装最新版，请带上版本号：
+
+```bash
+dsh plugin --profile web add dsh-logicprobe@<version>
+```
+
+pnpm 会把该版本写进 profile 的 `pnpm-workspace.yaml` 的 `minimumReleaseAgeExclude` 条目。那是它官方的豁免方式。
+
 > 注意包名。npm 包名是 `dsh-logicprobe`，没有 scope。在 web profile 的 `package.json` 中，依赖键与 `dsh.profile.bundles` 必须都写 `dsh-logicprobe`。写错时 dsh 加载器找不到 `node_modules/dsh-logicprobe`，启动会失败。
 
 ## UML 建模与审查

package/lib/engine.js

@@ -1721,31 +1721,67 @@ function S8_monotonicVariables(model) {
     }
     return checkResult('S8', 'Monotonic Variables', findings, findings.length === 0 ? 'Monotonic variables are respected' : 'Monotonic findings: ' + findings.length);
 }
+/**
+ * Find a run from `start` that never reaches `target`, or return undefined when
+ * every run does. The property is universal (see the A9 row in `SKILL.md`): one
+ * branch that loops forever, or that stops before the target, refutes it.
+ *
+ * The search is a depth-first walk of the run graph with three colours, and target
+ * runs are success leaves that are never expanded:
+ *
+ * - a node reached while it is on the current walk (GRAY) closes a cycle that avoids
+ *   the target, so some run never reaches it;
+ * - a node with no outgoing step at all stops the machine where it stands, which is
+ *   the same violation for a different reason;
+ * - a node whose walk completed without a violation is BLACK, and reaching it again
+ *   from another branch is a shared sub-graph, not a cycle.
+ *
+ * That last point is why the colour map cannot be a plain visited set: a diamond
+ * (two branches rejoining) is acyclic and must pass, while a genuine cycle must not.
+ * A run is identified by its state plus its variable values, so the same state id
+ * with different values is a different node.
+ */
 function findLeadsToBadPath(model, start, target) {
     if (start.state === target)
         return undefined;
-    const visited = new Set();
-    const queue = [{ runtime: start, path: [] }];
-    while (queue.length > 0) {
-        const entry = queue.shift();
-        const key = runtimeKey(entry.runtime);
-        if (entry.runtime.state === target)
-            continue;
-        if (visited.has(key))
-            return { path: entry.path, reason: 'Cycle avoids target ' + target };
-        visited.add(key);
-        const nexts = [];
-        for (const event of allEvents(model)) {
-            for (const next of stepRuntime(model, entry.runtime, event))
-                nexts.push({ next, event });
+    const GRAY = 1;
+    const BLACK = 2;
+    const color = new Map();
+    const stack = [{ runtime: start, path: [], nexts: undefined, index: 0 }];
+    color.set(runtimeKey(start), GRAY);
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        if (frame.nexts === undefined) {
+            const nexts = [];
+            for (const event of allEvents(model)) {
+                for (const next of stepRuntime(model, frame.runtime, event))
+                    nexts.push({ next, event });
+            }
+            frame.nexts = nexts;
+            if (nexts.length === 0)
+                return { path: frame.path, reason: 'Dead end before target ' + target };
         }
-        if (nexts.length === 0)
-            return { path: entry.path, reason: 'Dead end before target ' + target };
-        for (const { next, event } of nexts) {
-            queue.push({ runtime: next, path: [...entry.path, { from: entry.runtime.state, event, to: next.state }] });
+        if (frame.index >= frame.nexts.length) {
+            color.set(runtimeKey(frame.runtime), BLACK);
+            stack.pop();
+            continue;
         }
+        const { next, event } = frame.nexts[frame.index];
+        frame.index += 1;
+        const step = { from: frame.runtime.state, event, to: next.state };
+        if (next.state === target)
+            continue;
+        const key = runtimeKey(next);
+        const seen = color.get(key);
+        if (seen === GRAY)
+            return { path: [...frame.path, step], reason: 'Cycle avoids target ' + target };
+        if (seen === BLACK)
+            continue;
+        color.set(key, GRAY);
+        stack.push({ runtime: next, path: [...frame.path, step], nexts: undefined, index: 0 });
     }
-    return { path: [], reason: 'No path reaches target ' + target };
+    // Every branch either reached the target or rejoined a branch that did.
+    return undefined;
 }
 function A9_leadsTo(model, exploration) {
     const findings = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-logicprobe",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Design document & plan claim verification — enumerate claims, verify against codebase facts, then escalate to state-machine verification (S1-S8/A1-A12, including budget/worst-case path-cost checks) and data-model verification (DS/DA/DD) for behavioral claims. Supports before/after regression, idempotency/monotonic/sequence/leads-to/atomicity constraints, and concurrency risk mining. Ships a native DeepSeek Harness (dsh) bundle that injects the claim-verification gate into the first model step.",
   "type": "module",
   "main": "lib/index.js",
@@ -91,17 +91,22 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/dsh-agent": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-cordis-host-runner": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-home-paths": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-scope": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-skill": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-skill-filesystem": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-timeout": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-agent": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-cordis-host-runner": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-home-paths": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-invariants": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-ptc-runtime": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-sandbox-policy": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-scope": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-session": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-skill": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-skill-filesystem": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-timeout": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.2.0-rc.2",
+    "@deepseek-ai/dsh-user-approval": "^0.2.0-rc.2",
     "@deepseek-ai/schemastery": "^3.18.4",
     "@types/node": "^26.6.3",
     "typescript": "^7.0.2"

package/skills/logicprobe/references/logicprobe-engine.py

@@ -1870,28 +1870,55 @@ def S8_monotonic_variables(model):
 
 
 def _find_leads_to_bad_path(model, start, target):
+    # Find a run from start that never reaches target, or None when every run does.
+    # The property is universal (see the A9 row in SKILL.md): one branch that loops
+    # forever, or that stops before the target, refutes it.
+    #
+    # Depth-first walk of the run graph with three colours; target runs are success
+    # leaves that are never expanded. A node reached while it is on the current walk
+    # (GRAY) closes a cycle that avoids the target. A node with no outgoing step at
+    # all stops the machine where it stands, which is the same violation for a
+    # different reason. A node whose walk completed without a violation is BLACK, and
+    # reaching it again from another branch is a shared sub-graph, not a cycle -- that
+    # is why the colour map cannot be a plain visited set: a diamond (two branches
+    # rejoining) is acyclic and must pass, while a genuine cycle must not. A run is
+    # identified by its state plus its variable values.
     if start['state'] == target:
         return None
-    visited = set()
-    queue = deque([{'runtime': start, 'path': []}])
-    while queue:
-        entry = queue.popleft()
-        k = _runtime_key(entry['runtime'])
-        if entry['runtime']['state'] == target:
+    GRAY = 1
+    BLACK = 2
+    color = {}
+    stack = [{'runtime': start, 'path': [], 'nexts': None, 'index': 0}]
+    color[_runtime_key(start)] = GRAY
+    while stack:
+        frame = stack[-1]
+        if frame['nexts'] is None:
+            nexts = []
+            for event in _all_events(model):
+                for nxt in _step_runtime(model, frame['runtime'], event):
+                    nexts.append({'next': nxt, 'event': event})
+            frame['nexts'] = nexts
+            if not nexts:
+                return {'path': frame['path'], 'reason': 'Dead end before target ' + target}
+        if frame['index'] >= len(frame['nexts']):
+            color[_runtime_key(frame['runtime'])] = BLACK
+            stack.pop()
             continue
-        if k in visited:
-            return {'path': entry['path'], 'reason': 'Cycle avoids target ' + target}
-        visited.add(k)
-        nexts = []
-        for event in _all_events(model):
-            for nxt in _step_runtime(model, entry['runtime'], event):
-                nexts.append({'next': nxt, 'event': event})
-        if not nexts:
-            return {'path': entry['path'], 'reason': 'Dead end before target ' + target}
-        for item in nexts:
-            queue.append({'runtime': item['next'],
-                          'path': list(entry['path']) + [{'from': entry['runtime']['state'], 'event': item['event'], 'to': item['next']['state']}]})
-    return {'path': [], 'reason': 'No path reaches target ' + target}
+        item = frame['nexts'][frame['index']]
+        frame['index'] += 1
+        step = {'from': frame['runtime']['state'], 'event': item['event'], 'to': item['next']['state']}
+        if item['next']['state'] == target:
+            continue
+        key = _runtime_key(item['next'])
+        seen = color.get(key)
+        if seen == GRAY:
+            return {'path': frame['path'] + [step], 'reason': 'Cycle avoids target ' + target}
+        if seen == BLACK:
+            continue
+        color[key] = GRAY
+        stack.append({'runtime': item['next'], 'path': frame['path'] + [step], 'nexts': None, 'index': 0})
+    # Every branch either reached the target or rejoined a branch that did.
+    return None
 
 
 def A9_leads_to(model, exploration):

package/src/engine.ts

@@ -1824,26 +1824,68 @@ function S8_monotonicVariables(model: LogicModelV1): CheckResult {
   return checkResult('S8', 'Monotonic Variables', findings, findings.length === 0 ? 'Monotonic variables are respected' : 'Monotonic findings: ' + findings.length)
 }
 
+/**
+ * Find a run from `start` that never reaches `target`, or return undefined when
+ * every run does. The property is universal (see the A9 row in `SKILL.md`): one
+ * branch that loops forever, or that stops before the target, refutes it.
+ *
+ * The search is a depth-first walk of the run graph with three colours, and target
+ * runs are success leaves that are never expanded:
+ *
+ * - a node reached while it is on the current walk (GRAY) closes a cycle that avoids
+ *   the target, so some run never reaches it;
+ * - a node with no outgoing step at all stops the machine where it stands, which is
+ *   the same violation for a different reason;
+ * - a node whose walk completed without a violation is BLACK, and reaching it again
+ *   from another branch is a shared sub-graph, not a cycle.
+ *
+ * That last point is why the colour map cannot be a plain visited set: a diamond
+ * (two branches rejoining) is acyclic and must pass, while a genuine cycle must not.
+ * A run is identified by its state plus its variable values, so the same state id
+ * with different values is a different node.
+ */
 function findLeadsToBadPath(model: LogicModelV1, start: RuntimeState, target: string): { path: PathStep[]; reason: string } | undefined {
   if (start.state === target) return undefined
-  const visited = new Set<string>()
-  const queue: Array<{ runtime: RuntimeState; path: PathStep[] }> = [{ runtime: start, path: [] }]
-  while (queue.length > 0) {
-    const entry = queue.shift()!
-    const key = runtimeKey(entry.runtime)
-    if (entry.runtime.state === target) continue
-    if (visited.has(key)) return { path: entry.path, reason: 'Cycle avoids target ' + target }
-    visited.add(key)
-    const nexts: Array<{ next: RuntimeState; event: string }> = []
-    for (const event of allEvents(model)) {
-      for (const next of stepRuntime(model, entry.runtime, event)) nexts.push({ next, event })
+  const GRAY = 1
+  const BLACK = 2
+  interface LeadFrame {
+    runtime: RuntimeState
+    path: PathStep[]
+    /** Outgoing steps, filled on first expansion; `undefined` means "not expanded yet". */
+    nexts: Array<{ next: RuntimeState; event: string }> | undefined
+    index: number
+  }
+  const color = new Map<string, number>()
+  const stack: LeadFrame[] = [{ runtime: start, path: [], nexts: undefined, index: 0 }]
+  color.set(runtimeKey(start), GRAY)
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1]
+    if (frame.nexts === undefined) {
+      const nexts: Array<{ next: RuntimeState; event: string }> = []
+      for (const event of allEvents(model)) {
+        for (const next of stepRuntime(model, frame.runtime, event)) nexts.push({ next, event })
+      }
+      frame.nexts = nexts
+      if (nexts.length === 0) return { path: frame.path, reason: 'Dead end before target ' + target }
     }
-    if (nexts.length === 0) return { path: entry.path, reason: 'Dead end before target ' + target }
-    for (const { next, event } of nexts) {
-      queue.push({ runtime: next, path: [...entry.path, { from: entry.runtime.state, event, to: next.state }] })
+    if (frame.index >= frame.nexts.length) {
+      color.set(runtimeKey(frame.runtime), BLACK)
+      stack.pop()
+      continue
     }
+    const { next, event } = frame.nexts[frame.index]
+    frame.index += 1
+    const step: PathStep = { from: frame.runtime.state, event, to: next.state }
+    if (next.state === target) continue
+    const key = runtimeKey(next)
+    const seen = color.get(key)
+    if (seen === GRAY) return { path: [...frame.path, step], reason: 'Cycle avoids target ' + target }
+    if (seen === BLACK) continue
+    color.set(key, GRAY)
+    stack.push({ runtime: next, path: [...frame.path, step], nexts: undefined, index: 0 })
   }
-  return { path: [], reason: 'No path reaches target ' + target }
+  // Every branch either reached the target or rejoined a branch that did.
+  return undefined
 }
 
 function A9_leadsTo(model: LogicModelV1, exploration: Exploration): CheckResult {