@ran-sh/dsh-crew 1.10.6 → 1.10.8

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-crew",
-  "version": "1.10.6",
+  "version": "1.10.8",
   "description": "Dispatch subtasks to DeepSeek Harness (DSH) agents as native subagents with live progress",
   "author": {
     "name": "ZSeven-W"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ran-sh/dsh-crew",
-  "version": "1.10.6",
+  "version": "1.10.8",
   "type": "module",
   "main": "./src/hub/entry.mjs",
   "bin": {

package/scripts/verify-mcp-client.mjs

@@ -0,0 +1,106 @@
+// Drives the installed release's own MCP server over stdio, so the client-side
+// dispatch path is exercised by the shipped code rather than by a long-running
+// session whose MCP process predates the fix.
+import { spawn } from 'node:child_process';
+
+const serverPath = process.argv[2];
+const scenario = process.argv[3] ?? 'zero-change';
+const child = spawn(process.execPath, [serverPath], { stdio: ['pipe', 'pipe', 'pipe'], env: process.env });
+
+let buffer = '';
+let nextId = 1;
+const pending = new Map();
+
+child.stdout.on('data', (chunk) => {
+  buffer += chunk.toString();
+  let index;
+  while ((index = buffer.indexOf('\n')) >= 0) {
+    const line = buffer.slice(0, index).trim();
+    buffer = buffer.slice(index + 1);
+    if (line === '') continue;
+    let message;
+    try { message = JSON.parse(line); } catch { continue; }
+    if (message.id !== undefined && pending.has(message.id)) {
+      const { resolve } = pending.get(message.id);
+      pending.delete(message.id);
+      resolve(message);
+    }
+  }
+});
+const stderr = [];
+child.stderr.on('data', (chunk) => stderr.push(chunk.toString()));
+
+function send(method, params) {
+  const id = nextId++;
+  child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
+  return new Promise((resolve) => pending.set(id, { resolve }));
+}
+function notify(method, params) {
+  child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, params })}\n`);
+}
+
+const scenarios = {
+  'zero-change': {
+    tool: 'dsh_run_worker',
+    arguments: {
+      task: 'Create a temporary PowerShell script at work/tmp-hello.ps1 that writes exactly the text 你好 to standard output with no trailing newline, run it, and verify its stdout is exactly 你好 byte-for-byte under both CP936 and UTF-8. Then delete the script and confirm the path no longer exists. Do not leave any file behind: the final workspace must be unchanged.',
+      cwd: 'D:/Users/48376/Desktop/crew-verify-1',
+      role: 'worker',
+      workspace: { worktree: 'none' },
+      constraints: { allow_no_changes: true, timeout_seconds: 600 },
+    },
+  },
+  'tool-list': { tool: null },
+};
+
+const scenarioSpec = scenarios[scenario];
+const init = await send('initialize', {
+  protocolVersion: '2024-11-05',
+  capabilities: {},
+  clientInfo: { name: 'crew-verify', version: '1' },
+});
+if (init.error) {
+  console.log('INIT_FAILED', JSON.stringify(init.error));
+  process.exit(1);
+}
+notify('notifications/initialized', {});
+console.log('SERVER', JSON.stringify(init.result?.serverInfo ?? null));
+
+const listed = await send('tools/list', {});
+const tools = (listed.result?.tools ?? []).map((t) => t.name);
+console.log('TOOLS', JSON.stringify(tools));
+
+if (scenarioSpec.tool) {
+  const started = Date.now();
+  const call = await send('tools/call', { name: scenarioSpec.tool, arguments: scenarioSpec.arguments });
+  console.log('ELAPSED_MS', Date.now() - started);
+  if (call.error) {
+    console.log('CALL_ERROR', JSON.stringify(call.error));
+  } else {
+    const text = (call.result?.content ?? []).map((c) => c.text ?? '').join('');
+    let parsed = null;
+    try { parsed = JSON.parse(text); } catch { /* keep raw */ }
+    if (parsed) {
+      const summary = parsed.evidence?.summary ?? {};
+      console.log('RESULT', JSON.stringify({
+        id: parsed.id,
+        phase: parsed.phase,
+        status: parsed.status,
+        isolation: parsed.isolation,
+        execution_cwd: parsed.execution_cwd,
+        task_status: summary.task_status,
+        tests_status: summary.tests_status,
+        delivery_complete: summary.delivery_complete,
+        workspace_evidence_ok: parsed.workspace_evidence_ok ?? parsed.evidence?.workspace_evidence_ok,
+        no_change_verified: parsed.outcome?.no_change_verified,
+        failure: parsed.failure?.reason_code ?? null,
+        error: parsed.error ?? null,
+      }, null, 1));
+    } else {
+      console.log('RAW', text.slice(0, 1500));
+    }
+  }
+}
+
+child.kill();
+if (stderr.length) console.log('STDERR_SAMPLE', stderr.join('').slice(0, 400));

package/src/mcp-runtime.mjs

@@ -222,6 +222,15 @@ export function buildMcpWorkflowRuntime(deps) {
         source,
         preset,
         delivery,
+        // Isolation belongs to this client: it already allocated the workspace
+        // and `spec.cwd` is the result. Saying so keeps the hub executing in that
+        // cwd instead of resolving an isolation of its own and allocating a
+        // second workspace — which put the work somewhere the client was not
+        // looking and captured no candidate for.
+        requested_isolation: 'shared',
+        // The same authorization the client was given, so the hub judges the
+        // workspace evidence against the same task contract.
+        allow_no_changes: spec.allow_no_changes === true,
       });
       spec.onAttemptStarted?.(spawned.id);
 

package/src/runtime-identity.mjs

@@ -36,7 +36,7 @@ export {
 // included in the identity contract.
 const RUNTIME_ID = randomUUID();
 
-export const RUNTIME_VERSION = '1.10.6';
+export const RUNTIME_VERSION = '1.10.8';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([

package/src/workflow-runtime.mjs

@@ -382,6 +382,10 @@ export function createWorkflowRuntime(adapters, {
           cwd: job.execution_cwd,
           effort: job.effort,
           timeout_seconds: job.timeout_seconds,
+          // Passed through so the executor judges the workspace evidence against
+          // the same task contract this workflow was given, instead of against a
+          // default that would refuse an authorization the caller granted.
+          allow_no_changes: job.allow_no_changes === true,
           policy,
           source: job.source,
           model_class_hint: job.model_class_hint,
@@ -441,11 +445,23 @@ export function createWorkflowRuntime(adapters, {
             }
           }
         }
-        outcome = applyWorkspaceEvidence(outcome, {
-          evidenceAvailable: workspaceEvidenceAvailable,
-          hasChanges: workspaceHasChanges,
-          allowNoChanges: job.allow_no_changes,
-        });
+        // A hub-dispatched attempt was already judged by the Hub, which sees the
+        // primary workspace. This client only has evidence of its own when it
+        // captured a candidate, which it can only do in a worktree it owns; for a
+        // shared workspace it has none. Re-running the gate here with no evidence
+        // judged the same report again with nothing to judge it against, and
+        // downgraded an authorized zero-change task the Hub had already verified
+        // to `partial`. Where the client has no evidence, the Hub's verdict is
+        // the one that was reached on evidence, so it stands.
+        const clientJudged = workspaceEvidenceAvailable;
+        const hubJudged = typeof ar.outcome?.workspace_evidence_ok === 'boolean';
+        if (clientJudged || !hubJudged) {
+          outcome = applyWorkspaceEvidence(outcome, {
+            evidenceAvailable: clientJudged,
+            hasChanges: workspaceHasChanges,
+            allowNoChanges: job.allow_no_changes,
+          });
+        }
         job.outcome = outcome;
 
         const reviewRequested = !isReviewJob && shouldAutoReview(config);

package/src/workflow.mjs

@@ -81,12 +81,18 @@ const NO_CHANGE_ASSERTION_RE = new RegExp(
 function isNoChangeAssertion(line) {
   const normalized = line
     .replace(/^(?:[-*+]\s+)+/, '')
-    .replace(/[`"'“”‘’]/g, '')
+    .replace(/[`"'“”‘’*_]/g, '')
     .replace(/[.!。！]+$/, '')
     .trim()
     .toLowerCase();
   if (normalized === '') return false;
-  return NO_CHANGE_ASSERTION_RE.test(normalized);
+  // The assertion is usually a whole line, but a report may also end with it —
+  // "**Final state: no files changed.**" is the same declaration stated as a
+  // summary. Testing each sentence and clause is what finds it without matching
+  // a phrase that merely appears inside an unrelated one.
+  return normalized
+    .split(/\s*(?:[.:;,—–()\[\]]|->)\s*/)
+    .some((fragment) => fragment !== '' && NO_CHANGE_ASSERTION_RE.test(fragment.trim()));
 }
 
 // Whether the report claims the workspace holds changes. A report that asserts