dsh-logicprobe 0.4.0 → 0.5.1

package/lib/data-tool.js

@@ -0,0 +1,61 @@
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { runDataVerification, DATA_ENGINE_SCHEMA_VERSION } from './data-engine.js';
+export const LOGICPROBE_DATAMODEL_VERIFY_TOOL_NAME = 'logicprobe_datamodel_verify';
+/**
+ * Model-visible DSH tool wrapping the bundled data-model verification engine.
+ * The model passes a DataModelV1 object; the engine validates it and returns
+ * DS/DA/DD checks. Optional beforeModel/fieldMapping/copyPairs/migrationMappings
+ * enable before/after data-model regression and migration coverage checks.
+ */
+export const logicProbeDataModelVerifyTool = defineTool({
+    name: LOGICPROBE_DATAMODEL_VERIFY_TOOL_NAME,
+    description: 'Run executable data-model verification (logicprobe-datamodel). Takes a DataModelV1 object with schemaVersion=1, entities ({name, fields, primaryKey?, uniqueKeys?, indexes?}), relationships?, invariants?, boundaryChecks?. Optional beforeModel/fieldMapping/copyPairs/migrationMappings/backupPairs enable migration coverage, copy consistency, rollback symmetry, and before/after data regression (DD1-DD4). Returns a report with DS/DA/DD checks. See skills/logicprobe-datamodel/references/data-model-schema.md.',
+    parameters: {
+        model: {
+            type: 'json',
+            required: true,
+            description: 'DataModelV1 data model to verify.',
+        },
+        beforeModel: {
+            type: 'json',
+            description: 'Optional BEFORE DataModelV1 data model for regression comparison.',
+        },
+        fieldMapping: {
+            type: 'json',
+            description: 'Optional object mapping BEFORE "Entity.field" paths to AFTER "Entity.field" paths.',
+        },
+        copyPairs: {
+            type: 'json',
+            description: 'Optional copy pairs: { id, sourceEntity, targetEntity, mapping: {sourceField: targetField} }.',
+        },
+        migrationMappings: {
+            type: 'json',
+            description: 'Optional migration mappings: { from: "Entity.field", to: "Entity.field", transform?, note? }.',
+        },
+        backupPairs: {
+            type: 'json',
+            description: 'Optional backup/restore pairs for DA7 rollback symmetry.',
+        },
+    },
+    output: {
+        schema: {
+            type: 'json',
+            description: 'logicprobe-datamodel verification report with summary and per-check findings.',
+        },
+        render(_args, value) {
+            return [{ type: 'text', text: JSON.stringify(value, null, 2) }];
+        },
+    },
+    timeoutMs: 10_000,
+    isConcurrencySafe: () => true,
+    async execute(args) {
+        return runDataVerification(args.model, {
+            beforeModel: args.beforeModel,
+            fieldMapping: args.fieldMapping,
+            copyPairs: args.copyPairs,
+            migrationMappings: args.migrationMappings,
+            backupPairs: args.backupPairs,
+        });
+    },
+});
+export { DATA_ENGINE_SCHEMA_VERSION };

package/lib/engine.js

@@ -123,6 +123,8 @@ export function validateModel(input) {
                     bad(path + '.max', 'must be a number');
                 if (typeof variable.min === 'number' && typeof variable.max === 'number' && variable.min > variable.max)
                     bad(path + '.max', 'must be >= min');
+                if (variable.monotonic !== undefined && variable.monotonic !== 'inc' && variable.monotonic !== 'dec')
+                    bad(path + '.monotonic', "must be 'inc' or 'dec'");
                 if (variable.kind === 'integer' && typeof variable.init === 'number') {
                     if (typeof variable.min === 'number' && variable.init < variable.min)
                         bad(path + '.init', 'must be >= min');
@@ -174,6 +176,34 @@ export function validateModel(input) {
                     if (typeof invariant.state !== 'string' || invariant.state.length === 0)
                         bad(path + '.state', 'must be a non-empty string');
                 }
+                else if (invariant.kind === 'leads-to') {
+                    if (typeof invariant.from !== 'string' || invariant.from.length === 0)
+                        bad(path + '.from', 'must be a non-empty string');
+                    if (typeof invariant.to !== 'string' || invariant.to.length === 0)
+                        bad(path + '.to', 'must be a non-empty string');
+                }
+                else if (invariant.kind === 'sequence') {
+                    if (!Array.isArray(invariant.events) || invariant.events.length === 0)
+                        bad(path + '.events', 'must be a non-empty array');
+                    else
+                        invariant.events.forEach((event, eventIndex) => {
+                            if (typeof event !== 'string' || event.length === 0)
+                                bad(path + '.events[' + eventIndex + ']', 'must be a non-empty string');
+                        });
+                }
+                else if (invariant.kind === 'atomicity') {
+                    if (!Array.isArray(invariant.events) || invariant.events.length === 0)
+                        bad(path + '.events', 'must be a non-empty array');
+                    else
+                        invariant.events.forEach((event, eventIndex) => {
+                            if (typeof event !== 'string' || event.length === 0)
+                                bad(path + '.events[' + eventIndex + ']', 'must be a non-empty string');
+                        });
+                    if (typeof invariant.commit !== 'string' || invariant.commit.length === 0)
+                        bad(path + '.commit', 'must be a non-empty string');
+                    if (invariant.rollback !== undefined && typeof invariant.rollback !== 'string')
+                        bad(path + '.rollback', 'must be a string');
+                }
                 else {
                     bad(path + '.kind', 'unknown invariant kind');
                 }
@@ -206,6 +236,15 @@ export function validateModel(input) {
                     bad(path + '.values', 'must be an array of numbers');
             });
     }
+    if (root.idempotentEvents !== undefined) {
+        if (!Array.isArray(root.idempotentEvents))
+            bad('idempotentEvents', 'must be an array');
+        else
+            root.idempotentEvents.forEach((entry, index) => {
+                if (typeof entry !== 'string' || entry.length === 0)
+                    bad('idempotentEvents[' + index + ']', 'must be a non-empty string');
+            });
+    }
     if (root.resourcePairs !== undefined) {
         if (!Array.isArray(root.resourcePairs))
             bad('resourcePairs', 'must be an array');
@@ -1269,6 +1308,220 @@ function buildComparisonSummary(before, after, mapping) {
         removedTransitions,
     };
 }
+function A8_idempotentReplay(model, exploration) {
+    const events = model.idempotentEvents ?? [];
+    const findings = [];
+    for (const event of events) {
+        for (const runtime of exploration.reachable) {
+            const onceOptions = stepRuntime(model, runtime, event);
+            if (onceOptions.length === 0)
+                continue;
+            for (const once of onceOptions) {
+                const twiceOptions = stepRuntime(model, once, event);
+                if (twiceOptions.length === 0) {
+                    findings.push({
+                        code: 'A8_NOT_REPLAYABLE',
+                        severity: 'warning',
+                        message: 'Idempotent event ' + event + ' is not replayable after first application from ' + runtime.state + '.',
+                        path: [{ from: runtime.state, event, to: once.state }],
+                        evidence: { state: runtime.state, event },
+                    });
+                    continue;
+                }
+                for (const twice of twiceOptions) {
+                    if (runtimeKey(twice) !== runtimeKey(once)) {
+                        findings.push({
+                            code: 'A8_NOT_IDEMPOTENT',
+                            severity: 'error',
+                            message: 'Idempotent event ' + event + ' changes state when applied twice from ' + runtime.state + '.',
+                            path: [{ from: runtime.state, event, to: once.state }, { from: once.state, event, to: twice.state }],
+                            evidence: { state: runtime.state, event, afterOnce: once, afterTwice: twice },
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return checkResult('A8', 'Idempotent Replay', findings, findings.length === 0 ? 'Idempotent events are replay-safe' : 'Idempotent replay findings: ' + findings.length);
+}
+function S8_monotonicVariables(model) {
+    const findings = [];
+    for (const variable of model.variables ?? []) {
+        if (variable.monotonic === undefined)
+            continue;
+        for (const transition of model.transitions) {
+            for (const update of transition.updates ?? []) {
+                if (update.variable !== variable.name)
+                    continue;
+                if (variable.monotonic === 'inc' && update.op === 'dec') {
+                    findings.push({ code: 'S8_MONOTONIC_DECREASE', severity: 'error', message: 'Monotonic (inc) variable ' + variable.name + ' is decreased by ' + transition.event + '.', evidence: { variable: variable.name, transition } });
+                }
+                else if (variable.monotonic === 'dec' && update.op === 'inc') {
+                    findings.push({ code: 'S8_MONOTONIC_INCREASE', severity: 'error', message: 'Monotonic (dec) variable ' + variable.name + ' is increased by ' + transition.event + '.', evidence: { variable: variable.name, transition } });
+                }
+                else if (update.op === 'set') {
+                    findings.push({ code: 'S8_MONOTONIC_SET_REVIEW', severity: 'warning', message: 'Monotonic variable ' + variable.name + ' uses set in ' + transition.event + '; verify it cannot move backwards.', evidence: { variable: variable.name, transition } });
+                }
+            }
+        }
+    }
+    return checkResult('S8', 'Monotonic Variables', findings, findings.length === 0 ? 'Monotonic variables are respected' : 'Monotonic findings: ' + findings.length);
+}
+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 });
+        }
+        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 }] });
+        }
+    }
+    return { path: [], reason: 'No path reaches target ' + target };
+}
+function A9_leadsTo(model, exploration) {
+    const findings = [];
+    for (const invariant of model.invariants ?? []) {
+        if (invariant.kind !== 'leads-to')
+            continue;
+        for (const runtime of exploration.reachable) {
+            if (runtime.state !== invariant.from)
+                continue;
+            const bad = findLeadsToBadPath(model, runtime, invariant.to);
+            if (bad !== undefined) {
+                findings.push({
+                    code: 'A9_LEADS_TO_VIOLATION',
+                    severity: 'error',
+                    message: 'Leads-to invariant "' + invariant.id + '" violated from ' + invariant.from + ': ' + bad.reason,
+                    path: bad.path,
+                    evidence: { invariant },
+                });
+                break;
+            }
+        }
+    }
+    return checkResult('A9', 'Leads-To', findings, findings.length === 0 ? 'All leads-to invariants hold' : 'Leads-to findings: ' + findings.length);
+}
+function findSequenceViolation(model, options, invariant) {
+    const events = invariant.events;
+    const init = initialState(model);
+    const key = (runtime, progress) => runtimeKey(runtime) + '|' + progress;
+    const visited = new Set([key(init, 0)]);
+    const queue = [{ runtime: init, progress: 0, path: [] }];
+    let steps = 0;
+    while (queue.length > 0) {
+        const entry = queue.shift();
+        if (++steps > options.maxStates)
+            break;
+        for (const event of allEvents(model)) {
+            for (const next of stepRuntime(model, entry.runtime, event)) {
+                let progress = entry.progress;
+                let violation = false;
+                if (progress < events.length && event === events[progress]) {
+                    progress += 1;
+                }
+                else {
+                    const index = events.indexOf(event);
+                    if (index > progress)
+                        violation = true;
+                }
+                const path = [...entry.path, { from: entry.runtime.state, event, to: next.state }];
+                if (violation) {
+                    return { invariant, path, reason: 'Event ' + event + ' occurred before ' + events[progress] };
+                }
+                const nextKey = key(next, progress);
+                if (!visited.has(nextKey)) {
+                    visited.add(nextKey);
+                    queue.push({ runtime: next, progress, path });
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function A10_sequenceOrder(model, options) {
+    const findings = [];
+    for (const invariant of model.invariants ?? []) {
+        if (invariant.kind !== 'sequence')
+            continue;
+        const violation = findSequenceViolation(model, options, invariant);
+        if (violation !== undefined) {
+            findings.push({
+                code: 'A10_SEQUENCE_VIOLATION',
+                severity: 'error',
+                message: 'Sequence invariant "' + invariant.id + '" violated: ' + violation.reason,
+                path: violation.path,
+                evidence: { invariant },
+            });
+        }
+    }
+    return checkResult('A10', 'Sequence Order', findings, findings.length === 0 ? 'All sequence invariants hold' : 'Sequence findings: ' + findings.length);
+}
+function findAtomicityViolation(model, options, invariant) {
+    const atomic = new Set(invariant.events);
+    const init = initialState(model);
+    const key = (runtime, started, closed) => runtimeKey(runtime) + '|' + (started ? '1' : '0') + '|' + (closed ? '1' : '0');
+    const visited = new Set([key(init, false, false)]);
+    const queue = [{ runtime: init, started: false, closed: false, path: [] }];
+    let steps = 0;
+    while (queue.length > 0) {
+        const entry = queue.shift();
+        if (++steps > options.maxStates)
+            break;
+        for (const event of allEvents(model)) {
+            for (const next of stepRuntime(model, entry.runtime, event)) {
+                const started = entry.started || atomic.has(event);
+                const closed = entry.closed || event === invariant.commit || (invariant.rollback !== undefined && event === invariant.rollback);
+                const path = [...entry.path, { from: entry.runtime.state, event, to: next.state }];
+                if (entry.started && !entry.closed && !atomic.has(event) && event !== invariant.commit && event !== invariant.rollback) {
+                    return { invariant, path, reason: 'Left atomic scope via ' + event + ' without commit/rollback' };
+                }
+                if (started && !closed && isTerminal(model, next.state)) {
+                    return { invariant, path, reason: 'Terminal state reached with incomplete atomic group' };
+                }
+                const nextKey = key(next, started, closed);
+                if (!visited.has(nextKey)) {
+                    visited.add(nextKey);
+                    queue.push({ runtime: next, started, closed, path });
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function A11_atomicity(model, options) {
+    const findings = [];
+    for (const invariant of model.invariants ?? []) {
+        if (invariant.kind !== 'atomicity')
+            continue;
+        const violation = findAtomicityViolation(model, options, invariant);
+        if (violation !== undefined) {
+            findings.push({
+                code: 'A11_ATOMICITY_VIOLATION',
+                severity: 'error',
+                message: 'Atomicity invariant "' + invariant.id + '" violated: ' + violation.reason,
+                path: violation.path,
+                evidence: { invariant },
+            });
+        }
+    }
+    return checkResult('A11', 'Atomicity', findings, findings.length === 0 ? 'All atomicity invariants hold' : 'Atomicity findings: ' + findings.length);
+}
 // ---------------------------------------------------------------------------
 // main entry
 // ---------------------------------------------------------------------------
@@ -1303,6 +1556,7 @@ export function runVerification(input, options = {}) {
         S5_eventCompleteness(model),
         S6_guardCompleteness(model),
         S7_invariants(model, normalized),
+        S8_monotonicVariables(model),
         A1_unexpectedEvents(model),
         A2_raceInterleaving(model, exploration),
         A3_orderPermutation(model, normalized),
@@ -1310,6 +1564,10 @@ export function runVerification(input, options = {}) {
         A5_boundaryBlast(model),
         A6_resourceInjection(model),
         A7_shortestViolations(model, normalized),
+        A8_idempotentReplay(model, exploration),
+        A9_leadsTo(model, exploration),
+        A10_sequenceOrder(model, normalized),
+        A11_atomicity(model, normalized),
     ];
     let comparison;
     if (options.beforeModel !== undefined) {

package/lib/index.js

@@ -29,6 +29,8 @@ import z from '@deepseek-ai/schemastery';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { FileSystemSkillProvider } from '@deepseek-ai/dsh-skill-filesystem';
 import { logicProbeVerifyTool } from './tool.js';
+import { logicProbeDataModelVerifyTool, DATA_ENGINE_SCHEMA_VERSION } from './data-tool.js';
+import { logicProbeConcurrencyScanTool } from './concurrency-tool.js';
 import { ENGINE_SCHEMA_VERSION } from './engine.js';
 export const name = 'logicprobe';
 // Skills are contributed through the registry service, which dsh-base always
@@ -39,23 +41,23 @@ export const inject = ['skills'];
 // lands on `<package>/skills` regardless of where the package was installed.
 const SKILLS_DIR = fileURLToPath(new URL('../skills', import.meta.url));
 const GATE_PLUGIN_ID = 'logicprobe';
-const DEFAULT_GATE_CONTENT = `<EXTREMELY_IMPORTANT>
-Plugin logicprobe is active. Documents are not truth — code is. Verify every verifiable claim before accepting or acting on any design.
-
-**1% Rule**: If there is even a 1% chance the logicprobe skill applies — reviewing design documents, architecture specs, technical proposals, or refactoring plans that make claims about API names, file locations, enum values, mechanism feasibility, state machines, protocol logic, or behavioral guarantees ("always"/"never"/"guaranteed") — load it with the skill tool before responding. The cost of loading is trivial compared to the cost of a false claim.
-
-**Red Flags** — if you think any of these, STOP. You are rationalizing:
-
-| You think | Reality |
-|-----------|---------|
-| "This plan is too simple to verify" | The skill auto-classifies depth (LIGHTWEIGHT / STANDARD / ESCALATED). You don't decide. |
-| "I already know the file paths are correct" | Organic verification leaves no audit trail. Run Phase 0, append the "## Plan Verification" block. |
-| "I'll verify while implementing" | Verification happens before implementation, not during. |
-| "I can check this with reasoning alone" | Behavioral claims are verified with code/models, not intuition. One counter-example refutes a universal claim. |
-
-**Native verification path**: In dsh, prefer the \`logicprobe_verify\` tool for executable state-machine checks. The skill's Python harness remains the fallback for non-dsh hosts.
-
-**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" — suggest logicprobe as an optional verification pass (do not auto-escalate).
+const DEFAULT_GATE_CONTENT = `<EXTREMELY_IMPORTANT>
+Plugin logicprobe is active. Documents are not truth — code is. Verify every verifiable claim before accepting or acting on any design.
+
+**1% Rule**: If there is even a 1% chance the logicprobe skill applies — reviewing design documents, architecture specs, technical proposals, or refactoring plans that make claims about API names, file locations, enum values, mechanism feasibility, state machines, protocol logic, data models, schema migrations, data invariants, or behavioral guarantees ("always"/"never"/"guaranteed") — load it with the skill tool before responding. The cost of loading is trivial compared to the cost of a false claim.
+
+**Red Flags** — if you think any of these, STOP. You are rationalizing:
+
+| You think | Reality |
+|-----------|---------|
+| "This plan is too simple to verify" | The skill auto-classifies depth (LIGHTWEIGHT / STANDARD / ESCALATED). You don't decide. |
+| "I already know the file paths are correct" | Organic verification leaves no audit trail. Run Phase 0, append the "## Plan Verification" block. |
+| "I'll verify while implementing" | Verification happens before implementation, not during. |
+| "I can check this with reasoning alone" | Behavioral claims are verified with code/models, not intuition. One counter-example refutes a universal claim. |
+
+**Native verification path**: In dsh, prefer the \`logicprobe_verify\` tool for state-machine checks and \`logicprobe_datamodel_verify\` for data-model/schema migration checks. Both support before/after regression and common domain constraints (idempotency, monotonic, sequence, leads-to, atomicity). Python harnesses remain the fallback for non-dsh hosts.
+
+**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>`;
 export const Config = z.object({
     enabled: z.boolean().default(true),
@@ -96,7 +98,7 @@ function resolveInteraction(config, session) {
 function modeContextText(config, session) {
     const interaction = resolveInteraction(config, session);
     const lines = [
-        'logicprobe: use the `logicprobe_verify` tool for executable state-machine verification.',
+        'logicprobe: use `logicprobe_verify` for state machines and `logicprobe_datamodel_verify` for data models; both cover before/after regression and common domain constraints.',
         interaction === 'auto'
             ? 'logicprobe interaction=auto: do NOT call ask_user_question for model confirmation; run round-trip validation of the extracted transition table and mark the result UNCONFIRMED.'
             : 'logicprobe interaction=ask: show the extracted transition table and get user confirmation before running verification.',
@@ -111,7 +113,7 @@ function modeContextText(config, session) {
  * lets the model read this plugin's runtime status without guessing. Mirrors
  * the registration pattern of the official dsh-tool-cordis host providers.
  */
-function inspectProvider(config, isToolRegistered) {
+function inspectProvider(config, isToolRegistered, isDataToolRegistered, isConcurrencyToolRegistered) {
     return {
         manifest: {
             id: 'logicprobe',
@@ -133,9 +135,12 @@ function inspectProvider(config, isToolRegistered) {
                             gateContentLength: { type: 'integer', description: 'Length in characters of the injected gate text.' },
                             interaction: { type: 'string', enum: ['ask', 'auto', 'follow-approval'], description: 'Configured interaction mode. follow-approval resolves per session from approval/policy.' },
                             toolRegistered: { type: 'boolean', description: 'Whether the logicprobe_verify tool is registered on ctx.tools.' },
-                            engineSchemaVersion: { type: 'integer', description: 'Model schema version the bundled verification engine accepts.' },
+                            dataToolRegistered: { type: 'boolean', description: 'Whether the logicprobe_datamodel_verify tool is registered on ctx.tools.' },
+                            concurrencyToolRegistered: { type: 'boolean', description: 'Whether the logicprobe_concurrency_scan tool is registered on ctx.tools.' },
+                            engineSchemaVersion: { type: 'integer', description: 'Model schema version the bundled state-machine verification engine accepts.' },
+                            dataEngineSchemaVersion: { type: 'integer', description: 'Model schema version the bundled data-model verification engine accepts.' },
                         },
-                        required: ['enabled', 'gateContentLength', 'interaction', 'toolRegistered', 'engineSchemaVersion'],
+                        required: ['enabled', 'gateContentLength', 'interaction', 'toolRegistered', 'dataToolRegistered', 'concurrencyToolRegistered', 'engineSchemaVersion', 'dataEngineSchemaVersion'],
                         additionalProperties: false,
                     },
                 },
@@ -148,7 +153,10 @@ function inspectProvider(config, isToolRegistered) {
                     gateContentLength: config.gateContent.length,
                     interaction: config.interaction,
                     toolRegistered: isToolRegistered(),
+                    dataToolRegistered: isDataToolRegistered(),
+                    concurrencyToolRegistered: isConcurrencyToolRegistered(),
                     engineSchemaVersion: ENGINE_SCHEMA_VERSION,
+                    dataEngineSchemaVersion: DATA_ENGINE_SCHEMA_VERSION,
                 };
             }
             return null;
@@ -161,6 +169,8 @@ export function apply(ctx, config) {
     // agent/pre-step — by then the app is fully booted.
     let providerRegistered = false;
     let toolRegistered = false;
+    let dataToolRegistered = false;
+    let concurrencyToolRegistered = false;
     let modeContextRegistered = false;
     const registerProvider = () => {
         if (providerRegistered)
@@ -169,7 +179,7 @@ export function apply(ctx, config) {
         if (inspect === undefined)
             return;
         try {
-            ctx.effect(() => inspect.register(inspectProvider(config, () => toolRegistered)), 'logicprobe: inspect provider');
+            ctx.effect(() => inspect.register(inspectProvider(config, () => toolRegistered, () => dataToolRegistered, () => concurrencyToolRegistered)), 'logicprobe: inspect provider');
             providerRegistered = true;
         }
         catch (err) {
@@ -184,10 +194,14 @@ export function apply(ctx, config) {
             return;
         try {
             ctx.effect(() => tools.register(logicProbeVerifyTool), 'logicprobe: verify tool');
+            ctx.effect(() => tools.register(logicProbeDataModelVerifyTool), 'logicprobe: data verify tool');
+            ctx.effect(() => tools.register(logicProbeConcurrencyScanTool), 'logicprobe: concurrency scan tool');
             toolRegistered = true;
+            dataToolRegistered = true;
+            concurrencyToolRegistered = true;
         }
         catch (err) {
-            console.warn('[logicprobe] logicprobe_verify tool registration failed', err);
+            console.warn('[logicprobe] logicprobe_verify/logicprobe_datamodel_verify tool registration failed', err);
         }
     };
     const registerModeContext = () => {

package/lib/tool.js

@@ -11,7 +11,7 @@ export const LOGICPROBE_VERIFY_TOOL_NAME = 'logicprobe_verify';
  */
 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?}), variables?, invariants?, concurrentPairs?, boundaryChecks?, resourcePairs?. Guards are structured ({variable, op, value} | {all} | {any} | {not}); invariants support never-states, var-in-range, and event-before-state. Returns a report with S1-S7 structural checks and A1-A7 adversarial 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.',
+    description: 'Run executable state-machine verification (logicprobe). Takes a LogicModelV1 object with schemaVersion=1, init, states ({id, terminal?}), transitions ({from, event, to, guard?, updates?}), variables?, invariants?, concurrentPairs?, boundaryChecks?, resourcePairs?, idempotentEvents?. Guards are structured ({variable, op, value} | {all} | {any} | {not}); invariants support never-states, var-in-range, event-before-state, leads-to, sequence, and atomicity; variables support monotonic inc/dec. Returns a report with S1-S7 structural checks and A1-A7 adversarial 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',

package/lib/types/concurrency-tool.d.ts

@@ -0,0 +1,8 @@
+export declare 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 declare const logicProbeConcurrencyScanTool: import("@deepseek-ai/dsh-tools").ToolDefinition;

package/lib/types/concurrency.d.ts

@@ -0,0 +1,20 @@
+export interface ConcurrencyFinding {
+    code: 'CONCURRENCY_KEYWORD' | 'CONCURRENCY_ABSOLUTE_CLAIM';
+    severity: 'warning' | 'error';
+    message: string;
+    line?: number;
+    snippet?: string;
+    keyword: string;
+}
+export interface ConcurrencyScanReport {
+    ok: boolean;
+    findings: ConcurrencyFinding[];
+    summary: {
+        lines: number;
+        keywords: number;
+        absoluteClaims: number;
+        warnings: number;
+        errors: number;
+    };
+}
+export declare function runConcurrencyScan(text: string): ConcurrencyScanReport;