@ran-sh/dsh-crew 2.0.3 → 2.0.5

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-crew",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "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": "2.0.3",
+  "version": "2.0.5",
   "type": "module",
   "main": "./src/hub/entry.mjs",
   "bin": {

package/src/install/install-legacy.mjs

@@ -600,7 +600,20 @@ export async function installClaudeCode({ home = homedir(), statusline = false,
   } catch (err) {
     actions.push(`cli: plugin install failed — run manually: claude plugin install ${PLUGIN_KEY} (${String(err?.message ?? err).slice(0, 120)})`);
   }
-  return { ok: true, actions };
+  // Report the state that resulted, not the step that was attempted. The CLI is
+  // best-effort — a machine without `claude` is a supported install, and its
+  // settings alone are correct — but a CLI that is present and slow, timed out,
+  // or failed leaves the snapshot exactly as stale as it was, and it is the
+  // snapshot that `installStatus` reads. Saying so here is what lets the caller
+  // stop printing a checkmark for a state it never verified.
+  if (claudeSnapshotReady(home, root)) return { ok: true, actions };
+  return {
+    ok: true,
+    degraded: true,
+    code: 'CLAUDE_PLUGIN_SNAPSHOT_STALE',
+    reason: `Claude Code has not loaded the plugin; run: claude plugin install ${PLUGIN_KEY}`,
+    actions,
+  };
 }
 
 export function installCodex({ home = homedir(), scope, root = ROOT, env = process.env } = {}) {

package/src/install/npx-lifecycle.mjs

@@ -2626,6 +2626,25 @@ function currentInstallationHealth({ home }) {
   return { installed: true, healthy: validated.ok && registered, validated, registered, pointer };
 }
 
+/**
+ * What the operator is told about the Claude Code integration.
+ *
+ * A missing `claude` CLI is a supported install, so `installClaudeCode` stays
+ * best-effort and keeps `ok: true`. A CLI that is present and fails or times out
+ * is a different thing: it leaves Claude Code without the plugin snapshot while
+ * the settings still name it, which is the state that later reads as "needs
+ * repair". This line used to be `${ok === false ? '✗' : '✓'}`, and since `ok` was
+ * never false, the failure branch could not fire and a broken integration was
+ * reported as a checkmark.
+ */
+export function claudeIntegrationLine(result) {
+  if (result?.ok === false) return '✗ Claude Code integration failed';
+  if (result?.degraded === true) {
+    return `- Claude Code integration registered, but not loaded: ${result.reason ?? 'plugin snapshot not refreshed'}`;
+  }
+  return '✓ Claude Code integration';
+}
+
 async function activateRelease({ home, releaseDir, manifest, log, installer, supervisorRoot = runningPackageRoot() }) {
   const registration = ensureCrewPluginRegistration({ home, root: releaseDir, name: manifest.name });
   if (!registration.ok) {
@@ -2668,10 +2687,10 @@ async function activateRelease({ home, releaseDir, manifest, log, installer, sup
 
   const claude = await installer.installClaudeCode({ home, root: integrationRoot });
   if (claude.ok === false) {
-    log(`✗ Claude Code integration failed`);
+    log(claudeIntegrationLine(claude));
     return false;
   }
-  log('✓ Claude Code integration');
+  log(claudeIntegrationLine(claude));
 
   // The official ~/.dsh/profiles/web tree is read-only: activation never
   // repairs or mutates the official bridge. The isolated 3210 Crew backend

package/src/mcp-runtime.mjs

@@ -283,8 +283,10 @@ export function buildMcpWorkflowRuntime(deps) {
     const config = getConfig();
     const isolation = config.execution?.isolation ?? 'worktree';
     // Explicit shared mode uses the requested workspace. Readonly profiles,
-    // including the default Reviewer, use a disposable worktree below so an
-    // accidental edit can be detected and never pollutes the primary tree.
+    // including the default Reviewer, take the disposable worktree below, so an
+    // accidental edit cannot reach the primary tree at all. A reviewer that was
+    // explicitly given a shared workspace still gets fingerprinted around its
+    // attempt, so an edit there is detected even though it is not prevented.
     if (job.requested_isolation === 'shared' || isolation === 'shared') {
       return { ok: true, execution_cwd: job.requested_cwd, isolation: 'shared', base_revision: null, primary_workspace_dirty: false, handle: null };
     }

package/src/runtime-identity.mjs

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

package/src/workflow-runtime.mjs

@@ -289,7 +289,10 @@ export function createWorkflowRuntime(adapters, {
 
   async function releaseWorkspace(job) {
     if (job.retain_workspace) {
-      job.workspace_retained = true;
+      // Retention means an isolated workspace was deliberately kept for
+      // recovery. A shared workspace is the caller's own and was never ours to
+      // keep, so an evidence failure there retains nothing.
+      if (job.workspaceHandle) job.workspace_retained = true;
       return;
     }
     if (!job.workspaceHandle) return;
@@ -342,7 +345,7 @@ export function createWorkflowRuntime(adapters, {
 
       if (isReviewJob) {
         transition(job, JOB_PHASES.REVIEWING, 'explicit reviewer');
-        const before = alloc?.ok && alloc.isolation === 'worktree' ? await safeCapture(adapters, job.execution_cwd, job.base_revision) : null;
+        const before = alloc?.ok ? await safeCapture(adapters, job.execution_cwd, job.base_revision) : null;
         // Explicit reviewers inspect the caller's stated task/workspace
         // directly. The bounded worker-candidate capsule belongs only to the
         // automatic post-worker review path; constructing it with no worker
@@ -553,8 +556,13 @@ export function createWorkflowRuntime(adapters, {
   }
 
   async function runReviewerAttempt(job, task, config, beforeCandidate, cwd = job.execution_cwd, baseRevision = job.base_revision) {
+    // Reviewing is the one role whose entire contract is "changed nothing", so
+    // its evidence is not exempted by isolation. In a worktree the pre-review
+    // candidate comes from the allocator or the worker and its absence is a real
+    // failure; a shared workspace has no such candidate, so fingerprint the tree
+    // the reviewer is about to touch — otherwise the reviewer is the one actor
+    // whose edits nothing observes.
     const requireFingerprint = (candidate) => {
-      if (job.isolation !== 'worktree') return;
       if (candidate?.ok === true && typeof candidate.fingerprint === 'string' && candidate.fingerprint.trim()) return;
       job.candidate_capture_failed = true;
       job.retain_workspace = true;
@@ -562,7 +570,9 @@ export function createWorkflowRuntime(adapters, {
         code: 'REVIEW_EVIDENCE_UNAVAILABLE',
       });
     };
-    requireFingerprint(beforeCandidate);
+    const before = beforeCandidate
+      ?? (job.isolation === 'worktree' ? null : await safeCapture(adapters, cwd, baseRevision));
+    requireFingerprint(before);
     const policy = resolveModelPolicy(config, 'reviewer', { attempt: 0 });
     const attemptId = attemptIdFor(adapters, job.id, 'review');
     job.current_attempt_id = attemptId;
@@ -594,9 +604,9 @@ export function createWorkflowRuntime(adapters, {
       fallback_reason: attemptView.selection_trace?.fallback_reason ?? null,
     }, 0);
     if (ar.status === 'failed' && attemptView.error_code) job.error_code = attemptView.error_code;
-    const afterCandidate = job.isolation === 'worktree' ? await safeCapture(adapters, cwd, baseRevision) : null;
+    const afterCandidate = await safeCapture(adapters, cwd, baseRevision);
     requireFingerprint(afterCandidate);
-    const review = normalizeReview({ attemptResult: ar, beforeCandidate, afterCandidate });
+    const review = normalizeReview({ attemptResult: ar, beforeCandidate: before, afterCandidate });
     recordCanonical(job, 'review.completed', {
       attempt_id: attemptView.id,
       status: review.status,