dsh-logicprobe 0.5.0 → 0.5.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Amethyst Luna
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Amethyst Luna
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.en-US.md

@@ -13,10 +13,11 @@ Design documents are not truth — code is. A claim-verification skill that chec
 | Phase | What |
 |-------|------|
 | Phase 1-2 | Enumerate every verifiable claim (API names, file paths, enum values, counts, mechanism feasibility) → verify each against the codebase with evidence |
-| Phase 2a | **7 structural checks** on extracted state-machine models: reachability, deadlock, liveness, determinism, event/guard completeness, invariant validity |
-| Phase 2b | **7 adversarial probes**: unexpected events, race interleaving, order permutation, pair symmetry (lock/unlock), boundary blast, resource injection, minimal counter-example |
+| Phase 2a | **8 structural checks** on extracted state-machine models: reachability, deadlock, liveness, determinism, event/guard completeness, invariant validity, monotonic variables |
+| Phase 2b | **11 adversarial probes**: unexpected events, race interleaving, order permutation, pair symmetry (lock/unlock), boundary blast, resource injection, minimal counter-example, idempotent replay, leads-to, sequence, atomicity |
 | Refactoring | Before/after model comparison — behavioral preservation, invariant continuity, deadlock regression, complexity claims |
 | Data models | DataModelV1 verification — DS/DA/DD checks, migration coverage, copy consistency, before/after breaking-change regression |
+| Concurrency risk mining | Scans documents/plans for concurrency safety claims (thread-safe, lock-free, race condition, interrupt safety, etc.) and flags them for dedicated verification |
 | Output | Structured findings with exact file:line evidence, severity classification, correction direction — never inline fixes |
 
 The model is always shown as a transition table and **confirmed with the user before running** — extraction errors are the dominant failure mode.

package/README.md

@@ -11,10 +11,11 @@
 | 阶段 | 内容 |
 |------|------|
 | Phase 1-2 | 枚举每个可验证声称（API 名、文件路径、枚举值、数量、机制可行性）→ 逐条对照代码库给出证据 |
-| Phase 2a | 对提取的状态机模型执行 **7 项结构检查**：可达性、死锁、活性、确定性、事件/守卫完备性、不变量有效性 |
-| Phase 2b | **7 种对抗探针**：意外事件、竞态交错、顺序置换、配对对称（lock/unlock）、边界轰炸、资源注入、最小反例 |
+| Phase 2a | 对提取的状态机模型执行 **8 项结构检查**：可达性、死锁、活性、确定性、事件/守卫完备性、不变量有效性、单调变量 |
+| Phase 2b | **11 种对抗探针**：意外事件、竞态交错、顺序置换、配对对称（lock/unlock）、边界轰炸、资源注入、最小反例、幂等重放、必达、顺序、原子性 |
 | 重构模式 | 前后模型对比——行为保持、不变量连续性、死锁回归、复杂度声称 |
 | 数据模型模式 | DataModelV1 数据模型验证——DS/DA/DD 检查，迁移覆盖、copy 一致性、before/after 破坏性变更回归 |
+| 并发风险挖掘 | 扫描文档/计划中的并发安全声称（thread-safe、lock-free、race condition、中断安全等），标记需要专用验证 |
 | 输出 | 结构化发现：精确 file:line 证据、严重性分级、修正方向——绝不在核查中直接改代码 |
 
 模型永远先以转换表形式展示并**经用户确认后才运行**——模型提取错误是验证的头号失败模式。

package/lib/concurrency-tool.js

@@ -1,34 +1,34 @@
-import { defineTool } from '@deepseek-ai/dsh-tools';
-import { runConcurrencyScan } from './concurrency.js';
-export const LOGICPROBE_CONCURRENCY_SCAN_TOOL_NAME = 'logicprobe_concurrency_scan';
-/**
- * Model-visible DSH tool that mines design documents/plans for concurrency-related
- * claims and risk keywords. It does not prove concurrency safety; it flags terms
- * such as "thread-safe", "lock-free", "race condition", "atomic", "mutex", etc.,
- * so the model can either provide dedicated evidence or mark the claim unverified.
- */
-export const logicProbeConcurrencyScanTool = defineTool({
-    name: LOGICPROBE_CONCURRENCY_SCAN_TOOL_NAME,
-    description: 'Scan a document or plan text for concurrency risk points. Use ONLY after confirming the target actually has concurrency requirements or behavior (threads, async tasks, interrupts, shared state, parallel execution). If the target is purely sequential, do not call this tool. Returns findings for keywords like thread-safe, lock-free, data race, race condition, atomic, synchronized, mutex, semaphore, shared variable, reentrant, interrupt-safe. Absolute claims (thread-safe, lock-free, no data race) are flagged as errors requiring dedicated verification.',
-    parameters: {
-        text: {
-            type: 'string',
-            required: true,
-            description: 'Document or plan text to scan for concurrency-related claims.',
-        },
-    },
-    output: {
-        schema: {
-            type: 'json',
-            description: 'Concurrency scan report with findings and summary.',
-        },
-        render(_args, value) {
-            return [{ type: 'text', text: JSON.stringify(value, null, 2) }];
-        },
-    },
-    timeoutMs: 10_000,
-    isConcurrencySafe: () => true,
-    async execute(args) {
-        return runConcurrencyScan(args.text);
-    },
-});
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { runConcurrencyScan } from './concurrency.js';
+export const LOGICPROBE_CONCURRENCY_SCAN_TOOL_NAME = 'logicprobe_concurrency_scan';
+/**
+ * Model-visible DSH tool that mines design documents/plans for concurrency-related
+ * claims and risk keywords. It does not prove concurrency safety; it flags terms
+ * such as "thread-safe", "lock-free", "race condition", "atomic", "mutex", etc.,
+ * so the model can either provide dedicated evidence or mark the claim unverified.
+ */
+export const logicProbeConcurrencyScanTool = defineTool({
+    name: LOGICPROBE_CONCURRENCY_SCAN_TOOL_NAME,
+    description: 'Scan a document or plan text for concurrency risk points. Use ONLY after confirming the target actually has concurrency requirements or behavior (threads, async tasks, interrupts, shared state, parallel execution). If the target is purely sequential, do not call this tool. Returns findings for keywords like thread-safe, lock-free, data race, race condition, atomic, synchronized, mutex, semaphore, shared variable, reentrant, interrupt-safe. Absolute claims (thread-safe, lock-free, no data race) are flagged as errors requiring dedicated verification.',
+    parameters: {
+        text: {
+            type: 'string',
+            required: true,
+            description: 'Document or plan text to scan for concurrency-related claims.',
+        },
+    },
+    output: {
+        schema: {
+            type: 'json',
+            description: 'Concurrency scan report with findings and summary.',
+        },
+        render(_args, value) {
+            return [{ type: 'text', text: JSON.stringify(value, null, 2) }];
+        },
+    },
+    timeoutMs: 10_000,
+    isConcurrencySafe: () => true,
+    async execute(args) {
+        return runConcurrencyScan(args.text);
+    },
+});

package/lib/concurrency.js

@@ -1,76 +1,76 @@
-const KEYWORD_RULES = [
-    { pattern: /\bthread\s*-?\s*safe\b/i, label: 'thread-safe', absolute: true },
-    { pattern: /\block\s*-?\s*free\b/i, label: 'lock-free', absolute: true },
-    { pattern: /\bwait\s*-?\s*free\b/i, label: 'wait-free', absolute: true },
-    { pattern: /\bno\s+data\s+race\b/i, label: 'no data race', absolute: true },
-    { pattern: /\brace\s*-?\s*free\b/i, label: 'race-free', absolute: true },
-    { pattern: /\bdata\s+race\b/i, label: 'data race', absolute: false },
-    { pattern: /\brace\s+condition\b/i, label: 'race condition', absolute: false },
-    { pattern: /\bthread\s*-?\s*safety\b/i, label: 'thread safety', absolute: false },
-    { pattern: /\bconcurrent\b/i, label: 'concurrent', absolute: false },
-    { pattern: /\bparallel\b/i, label: 'parallel', absolute: false },
-    { pattern: /\bmulti-?threaded\b/i, label: 'multi-threaded', absolute: false },
-    { pattern: /\bmultithreaded\b/i, label: 'multithreaded', absolute: false },
-    { pattern: /\batomic\b/i, label: 'atomic', absolute: false },
-    { pattern: /\bsynchronized\b/i, label: 'synchronized', absolute: false },
-    { pattern: /\bmutex\b/i, label: 'mutex', absolute: false },
-    { pattern: /\bsemaphore\b/i, label: 'semaphore', absolute: false },
-    { pattern: /\bspinlock\b/i, label: 'spinlock', absolute: false },
-    { pattern: /\bshared\s+variable\b/i, label: 'shared variable', absolute: false },
-    { pattern: /\bshared\s+memory\b/i, label: 'shared memory', absolute: false },
-    { pattern: /\bglobal\s+state\b/i, label: 'global state', absolute: false },
-    { pattern: /\breentrant\b/i, label: 'reentrant', absolute: false },
-    { pattern: /\binterrupt\s*-?\s*safe\b/i, label: 'interrupt-safe', absolute: true },
-    { pattern: /\bISR\s*-?\s*safe\b/i, label: 'ISR-safe', absolute: true },
-    { pattern: /\binterrupt\s+safety\b/i, label: 'interrupt safety', absolute: false },
-    { pattern: /\binterrupt\s+context\b/i, label: 'interrupt context', absolute: false },
-    { pattern: /\bISR\b/i, label: 'ISR', absolute: false },
-    { pattern: /\bIRQ\b/i, label: 'IRQ', absolute: false },
-    { pattern: /\bNMI\b/i, label: 'NMI', absolute: false },
-    { pattern: /\bcritical\s+section\b/i, label: 'critical section', absolute: false },
-    { pattern: /\bdisable_irq\b/i, label: 'disable_irq', absolute: false },
-    { pattern: /\benable_irq\b/i, label: 'enable_irq', absolute: false },
-    { pattern: /\bspin_lock_irqsave\b/i, label: 'spin_lock_irqsave', absolute: false },
-];
-export function runConcurrencyScan(text) {
-    const lines = text.split(/\r?\n/);
-    const findings = [];
-    const seen = new Set();
-    lines.forEach((line, index) => {
-        const lineNumber = index + 1;
-        const lower = line.toLowerCase();
-        for (const rule of KEYWORD_RULES) {
-            if (!rule.pattern.test(line))
-                continue;
-            const key = rule.label + ':' + lineNumber;
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            const finding = {
-                code: rule.absolute ? 'CONCURRENCY_ABSOLUTE_CLAIM' : 'CONCURRENCY_KEYWORD',
-                severity: rule.absolute ? 'error' : 'warning',
-                message: rule.absolute
-                    ? 'Concurrency safety claim "' + rule.label + '" detected; this requires dedicated verification (TSan, model checker, or explicit proof).'
-                    : 'Concurrency-related term "' + rule.label + '" detected; review whether the plan addresses this risk.',
-                line: lineNumber,
-                snippet: line.trim().slice(0, 200),
-                keyword: rule.label,
-            };
-            findings.push(finding);
-        }
-    });
-    const errors = findings.filter((finding) => finding.severity === 'error').length;
-    const warnings = findings.filter((finding) => finding.severity === 'warning').length;
-    const absoluteClaims = findings.filter((finding) => finding.code === 'CONCURRENCY_ABSOLUTE_CLAIM').length;
-    return {
-        ok: true,
-        findings,
-        summary: {
-            lines: lines.length,
-            keywords: findings.length,
-            absoluteClaims,
-            warnings,
-            errors,
-        },
-    };
-}
+const KEYWORD_RULES = [
+    { pattern: /\bthread\s*-?\s*safe\b/i, label: 'thread-safe', absolute: true },
+    { pattern: /\block\s*-?\s*free\b/i, label: 'lock-free', absolute: true },
+    { pattern: /\bwait\s*-?\s*free\b/i, label: 'wait-free', absolute: true },
+    { pattern: /\bno\s+data\s+race\b/i, label: 'no data race', absolute: true },
+    { pattern: /\brace\s*-?\s*free\b/i, label: 'race-free', absolute: true },
+    { pattern: /\bdata\s+race\b/i, label: 'data race', absolute: false },
+    { pattern: /\brace\s+condition\b/i, label: 'race condition', absolute: false },
+    { pattern: /\bthread\s*-?\s*safety\b/i, label: 'thread safety', absolute: false },
+    { pattern: /\bconcurrent\b/i, label: 'concurrent', absolute: false },
+    { pattern: /\bparallel\b/i, label: 'parallel', absolute: false },
+    { pattern: /\bmulti-?threaded\b/i, label: 'multi-threaded', absolute: false },
+    { pattern: /\bmultithreaded\b/i, label: 'multithreaded', absolute: false },
+    { pattern: /\batomic\b/i, label: 'atomic', absolute: false },
+    { pattern: /\bsynchronized\b/i, label: 'synchronized', absolute: false },
+    { pattern: /\bmutex\b/i, label: 'mutex', absolute: false },
+    { pattern: /\bsemaphore\b/i, label: 'semaphore', absolute: false },
+    { pattern: /\bspinlock\b/i, label: 'spinlock', absolute: false },
+    { pattern: /\bshared\s+variable\b/i, label: 'shared variable', absolute: false },
+    { pattern: /\bshared\s+memory\b/i, label: 'shared memory', absolute: false },
+    { pattern: /\bglobal\s+state\b/i, label: 'global state', absolute: false },
+    { pattern: /\breentrant\b/i, label: 'reentrant', absolute: false },
+    { pattern: /\binterrupt\s*-?\s*safe\b/i, label: 'interrupt-safe', absolute: true },
+    { pattern: /\bISR\s*-?\s*safe\b/i, label: 'ISR-safe', absolute: true },
+    { pattern: /\binterrupt\s+safety\b/i, label: 'interrupt safety', absolute: false },
+    { pattern: /\binterrupt\s+context\b/i, label: 'interrupt context', absolute: false },
+    { pattern: /\bISR\b/i, label: 'ISR', absolute: false },
+    { pattern: /\bIRQ\b/i, label: 'IRQ', absolute: false },
+    { pattern: /\bNMI\b/i, label: 'NMI', absolute: false },
+    { pattern: /\bcritical\s+section\b/i, label: 'critical section', absolute: false },
+    { pattern: /\bdisable_irq\b/i, label: 'disable_irq', absolute: false },
+    { pattern: /\benable_irq\b/i, label: 'enable_irq', absolute: false },
+    { pattern: /\bspin_lock_irqsave\b/i, label: 'spin_lock_irqsave', absolute: false },
+];
+export function runConcurrencyScan(text) {
+    const lines = text.split(/\r?\n/);
+    const findings = [];
+    const seen = new Set();
+    lines.forEach((line, index) => {
+        const lineNumber = index + 1;
+        const lower = line.toLowerCase();
+        for (const rule of KEYWORD_RULES) {
+            if (!rule.pattern.test(line))
+                continue;
+            const key = rule.label + ':' + lineNumber;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const finding = {
+                code: rule.absolute ? 'CONCURRENCY_ABSOLUTE_CLAIM' : 'CONCURRENCY_KEYWORD',
+                severity: rule.absolute ? 'error' : 'warning',
+                message: rule.absolute
+                    ? 'Concurrency safety claim "' + rule.label + '" detected; this requires dedicated verification (TSan, model checker, or explicit proof).'
+                    : 'Concurrency-related term "' + rule.label + '" detected; review whether the plan addresses this risk.',
+                line: lineNumber,
+                snippet: line.trim().slice(0, 200),
+                keyword: rule.label,
+            };
+            findings.push(finding);
+        }
+    });
+    const errors = findings.filter((finding) => finding.severity === 'error').length;
+    const warnings = findings.filter((finding) => finding.severity === 'warning').length;
+    const absoluteClaims = findings.filter((finding) => finding.code === 'CONCURRENCY_ABSOLUTE_CLAIM').length;
+    return {
+        ok: true,
+        findings,
+        summary: {
+            lines: lines.length,
+            keywords: findings.length,
+            absoluteClaims,
+            warnings,
+            errors,
+        },
+    };
+}