@ran-sh/dsh-crew 0.5.1 → 0.5.3

package/src/install/zcode.mjs

@@ -0,0 +1,316 @@
+// ZCode host integration.  This module is deliberately file-only: it never
+// launches ZCode, mutates credentials, or overwrites an unowned MCP server.
+// The generated files make ZCode dispatch through the same dsh-crew MCP server
+// used by Codex and Claude while keeping ZCode's native config precedence.
+
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const HOST = 'zcode';
+const SERVER = 'dsh-crew';
+const POLICY_START = '<!-- DSH CREW MANAGED ZCODE POLICY:START -->';
+const POLICY_END = '<!-- DSH CREW MANAGED ZCODE POLICY:END -->';
+const OWNERSHIP_FILE = ({ home = homedir() } = {}) => join(home, '.config', 'dsh-crew', 'integrations', 'zcode.json');
+
+// Keep the allowlist explicit. ZCode rejects wildcard tool permissions, and a
+// future server tool is not silently exposed until a template intentionally
+// opts into it.
+export const ZCODE_MCP_TOOLS = Object.freeze([
+  'dsh_run_worker',
+  'dsh_spawn_worker',
+  'dsh_worker_status',
+  'dsh_worker_result',
+  'dsh_worker_cancel',
+  'dsh_worker_config',
+]);
+
+function readText(file) {
+  try { return readFileSync(file, 'utf8'); } catch { return null; }
+}
+
+function readJson(file, fallback = null) {
+  try { return JSON.parse(readFileSync(file, 'utf8')); } catch { return fallback; }
+}
+
+function contentHash(text) {
+  return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+function writeJson(file, value) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function backup(file) {
+  if (!existsSync(file)) return null;
+  const path = `${file}.dsh-crew-backup-${Date.now()}`;
+  copyFileSync(file, path);
+  return path;
+}
+
+function normalizePath(value) {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  try {
+    const path = resolve(value);
+    return process.platform === 'win32' ? path.toLowerCase() : path;
+  } catch { return null; }
+}
+
+function serverTarget(server) {
+  if (!server || typeof server !== 'object') return null;
+  if (server.command !== 'node' || !Array.isArray(server.args) || typeof server.args[0] !== 'string') return null;
+  return normalizePath(server.args[0]);
+}
+
+function nativeServers(config) {
+  const servers = config?.mcp?.servers;
+  return servers && typeof servers === 'object' && !Array.isArray(servers) ? servers : {};
+}
+
+function sharedServers(config) {
+  const servers = config?.mcpServers;
+  return servers && typeof servers === 'object' && !Array.isArray(servers) ? servers : {};
+}
+
+function configSource({ home = homedir() } = {}) {
+  const nativeFile = join(home, '.zcode', 'cli', 'config.json');
+  const sharedFile = join(home, '.agents', 'mcp.json');
+  const native = readJson(nativeFile, {});
+  const shared = readJson(sharedFile, {});
+  const nativeMap = nativeServers(native);
+  const sharedMap = sharedServers(shared);
+  // ZCode shadows .agents/mcp.json whenever its native config has at least
+  // one server. If native is empty, the shared file is the least-surprising
+  // compatibility path for users who already manage MCP centrally.
+  if (Object.keys(nativeMap).length > 0 || Object.keys(sharedMap).length === 0) {
+    return { file: nativeFile, kind: 'native', config: native, servers: nativeMap };
+  }
+  return { file: sharedFile, kind: 'shared', config: shared, servers: sharedMap };
+}
+
+export function resolveZCodeMcpTarget({ home = homedir() } = {}) {
+  const source = configSource({ home });
+  return serverTarget(source.servers[SERVER]);
+}
+
+function expectedTarget({ root = ROOT } = {}) {
+  return resolve(join(root, 'src', 'server.mjs'));
+}
+
+function managedPolicyBlock(root) {
+  const template = readText(join(root, 'zcode', 'AGENTS.md'))?.trim();
+  return template ? `${POLICY_START}\n${template}\n${POLICY_END}` : null;
+}
+
+function installPolicy({ home, root }) {
+  const file = join(home, '.zcode', 'AGENTS.md');
+  const block = managedPolicyBlock(root);
+  if (!block) return { ok: false, code: 'ZCODE_POLICY_TEMPLATE_MISSING' };
+  mkdirSync(dirname(file), { recursive: true });
+  const current = readText(file) ?? '';
+  const escapedStart = POLICY_START.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const escapedEnd = POLICY_END.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const managed = new RegExp(`${escapedStart}[\\s\\S]*?${escapedEnd}`, 'm');
+  const next = managed.test(current)
+    ? current.replace(managed, block)
+    : `${current.trimEnd()}${current.trim() ? '\n\n' : ''}${block}\n`;
+  if (next !== current) { backup(file); writeFileSync(file, next); }
+  return { ok: true, file };
+}
+
+function removePolicy({ home }) {
+  const file = join(home, '.zcode', 'AGENTS.md');
+  const current = readText(file);
+  if (typeof current !== 'string') return false;
+  const start = POLICY_START.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const end = POLICY_END.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const managed = new RegExp(`(?:\\r?\\n){0,2}${start}[\\s\\S]*?${end}(?:\\r?\\n)?`, 'm');
+  if (!managed.test(current)) return false;
+  const next = current.replace(managed, '').trimEnd();
+  backup(file);
+  if (next.trim()) writeFileSync(file, `${next}\n`);
+  else rmSync(file, { force: true });
+  return true;
+}
+
+function ownership({ home = homedir() } = {}) {
+  const data = readJson(OWNERSHIP_FILE({ home }), null);
+  return data && typeof data === 'object' && data.host === HOST ? data : null;
+}
+
+function writeOwnership({ home, configFile, configKind, target, files = [] }) {
+  writeJson(OWNERSHIP_FILE({ home }), {
+    schema_version: 1,
+    host: HOST,
+    server: SERVER,
+    config_file: configFile,
+    config_kind: configKind,
+    target,
+    files,
+    managed_at: new Date().toISOString(),
+  });
+}
+
+function templateFiles({ home, root }) {
+  return [
+    ['agents', 'ds-worker.md'],
+    ['agents', 'ds-reviewer.md'],
+    ['commands', 'dsh-config.md'],
+    ['commands', 'dsh-status.md'],
+  ].map(([dir, file]) => ({ source: join(root, 'zcode', dir, file), dest: join(home, '.zcode', dir, file) }));
+}
+
+function installTemplates({ home, root, priorFiles = [] }) {
+  const actions = [];
+  const records = [];
+  for (const { source, dest } of templateFiles({ home, root })) {
+    if (!existsSync(source)) return { ok: false, code: 'ZCODE_TEMPLATE_MISSING', source };
+    mkdirSync(dirname(dest), { recursive: true });
+    const before = readText(dest);
+    const rendered = readFileSync(source, 'utf8');
+    const previous = priorFiles.find((entry) => entry?.path === dest);
+    let backupFile = previous?.backup ?? null;
+    if (before !== rendered) {
+      if (before !== null && !backupFile) backupFile = backup(dest);
+      writeFileSync(dest, rendered);
+    }
+    actions.push(dest);
+    records.push({
+      path: dest,
+      preexisting: previous?.preexisting === true || (previous === undefined && before !== null),
+      ...(backupFile ? { backup: backupFile } : {}),
+      managed_sha256: contentHash(rendered),
+    });
+  }
+  return { ok: true, actions, records };
+}
+
+function updateMcp({ home, root }) {
+  const source = configSource({ home });
+  const target = expectedTarget({ root });
+  const current = source.servers[SERVER];
+  const currentTarget = serverTarget(current);
+  const owned = ownership({ home });
+  if (current && currentTarget !== target) {
+    // Only an exact previously-owned entry may be repaired. Any foreign
+    // command, even if it is also named dsh-crew, is a hard collision.
+    if (!(owned && owned.config_file === source.file && normalizePath(owned.target) === currentTarget)) {
+      return { ok: false, code: 'ZCODE_MCP_COLLISION', config_file: source.file };
+    }
+  }
+
+  const next = { ...source.config };
+  if (source.kind === 'native') next.mcp = { ...(next.mcp ?? {}), servers: { ...source.servers, [SERVER]: { command: 'node', args: [target] } } };
+  else next.mcpServers = { ...source.servers, [SERVER]: { command: 'node', args: [target] } };
+  const changed = JSON.stringify(next) !== JSON.stringify(source.config);
+  if (changed) { backup(source.file); writeJson(source.file, next); }
+  return { ok: true, changed, config_file: source.file, config_kind: source.kind, target };
+}
+
+export function installZCode({ home = homedir(), root = ROOT } = {}) {
+  const templates = templateFiles({ home, root });
+  const missing = templates.find(({ source }) => !existsSync(source));
+  if (missing) return { ok: false, code: 'ZCODE_TEMPLATE_MISSING', source: missing.source };
+  const priorFiles = ownership({ home })?.files ?? [];
+  // Check for collisions before writing any other integration surface so a
+  // failed install is transaction-like and leaves user files untouched.
+  const mcp = updateMcp({ home, root });
+  if (!mcp.ok) return mcp;
+  const policy = installPolicy({ home, root });
+  if (!policy.ok) return policy;
+  const installed = installTemplates({ home, root, priorFiles });
+  if (!installed.ok) return installed;
+  writeOwnership({
+    home,
+    configFile: mcp.config_file,
+    configKind: mcp.config_kind,
+    target: mcp.target,
+    files: installed.records,
+  });
+  return { ok: true, ...mcp, policy_file: policy.file, files: installed.actions };
+}
+
+function zcodeComponents({ home = homedir(), root = ROOT } = {}) {
+  const expected = normalizePath(expectedTarget({ root }));
+  const source = configSource({ home });
+  const configured = serverTarget(source.servers[SERVER]);
+  const owned = ownership({ home });
+  const components = {
+    mcp: configured === expected,
+    policy: typeof readText(join(home, '.zcode', 'AGENTS.md')) === 'string' && readText(join(home, '.zcode', 'AGENTS.md')).includes(POLICY_START),
+    worker_agent: existsSync(join(home, '.zcode', 'agents', 'ds-worker.md')),
+    reviewer_agent: existsSync(join(home, '.zcode', 'agents', 'ds-reviewer.md')),
+    config_prompt: existsSync(join(home, '.zcode', 'commands', 'dsh-config.md')),
+    status_prompt: existsSync(join(home, '.zcode', 'commands', 'dsh-status.md')),
+    ownership: !!owned && owned.config_file === source.file && normalizePath(owned.target) === expected,
+  };
+  return { components, source, expected, configured, owned };
+}
+
+export function zcodeStatus({ home = homedir(), root = ROOT } = {}) {
+  const { components, source, expected, configured } = zcodeComponents({ home, root });
+  const missing = Object.entries(components).filter(([, value]) => !value).map(([key]) => key);
+  const installed = Object.values(components).some(Boolean);
+  return {
+    installed,
+    ready: missing.length === 0,
+    components,
+    missing,
+    config_file: source.file,
+    config_kind: source.kind,
+    target: configured ?? expected,
+  };
+}
+
+export function uninstallZCode({ home = homedir() } = {}) {
+  const actions = [];
+  const owned = ownership({ home });
+  if (owned) {
+    const file = owned.config_file;
+    const config = readJson(file, null);
+    if (config && typeof config === 'object') {
+      const kind = owned.config_kind === 'shared' ? 'shared' : 'native';
+      const servers = kind === 'shared' ? sharedServers(config) : nativeServers(config);
+      const current = servers[SERVER];
+      if (normalizePath(owned.target) === serverTarget(current)) {
+        const next = { ...config };
+        if (kind === 'shared') {
+          next.mcpServers = { ...servers }; delete next.mcpServers[SERVER];
+          if (Object.keys(next.mcpServers).length === 0) delete next.mcpServers;
+        } else {
+          next.mcp = { ...(next.mcp ?? {}), servers: { ...servers } }; delete next.mcp.servers[SERVER];
+          if (Object.keys(next.mcp.servers).length === 0) delete next.mcp.servers;
+          if (Object.keys(next.mcp).length === 0) delete next.mcp;
+        }
+        backup(file); writeJson(file, next); actions.push(`mcp: removed ${SERVER} from ${file}`);
+      }
+    }
+    rmSync(OWNERSHIP_FILE({ home }), { force: true });
+  }
+  if (removePolicy({ home })) actions.push('policy: removed managed ZCode block');
+  const managedFiles = Array.isArray(owned?.files) && owned.files.length
+    ? owned.files
+    : ['agents/ds-worker.md', 'agents/ds-reviewer.md', 'commands/dsh-config.md', 'commands/dsh-status.md']
+      .map((rel) => ({ path: join(home, '.zcode', rel) }));
+  for (const entry of managedFiles) {
+    const file = entry?.path;
+    if (!file || !existsSync(file)) continue;
+    const current = readText(file);
+    const unchanged = !entry.managed_sha256 || (current !== null && contentHash(current) === entry.managed_sha256);
+    if (!unchanged) continue;
+    if (entry.preexisting && entry.backup && existsSync(entry.backup)) {
+      copyFileSync(entry.backup, file);
+      actions.push(`restored: ${file}`);
+    } else {
+      rmSync(file, { force: true });
+      actions.push(`removed: ${file}`);
+    }
+  }
+  return { ok: true, actions };
+}
+
+export function zcodeOwnershipFile({ home = homedir() } = {}) { return OWNERSHIP_FILE({ home }); }

package/src/orchestrator.mjs

@@ -0,0 +1,53 @@
+import { execFileSync } from 'node:child_process';
+
+function explicitSource(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim().toLowerCase();
+  return /^[a-z0-9][a-z0-9._-]{0,63}$/.test(normalized) ? normalized : null;
+}
+
+function classifyParent(value) {
+  const firstLine = String(value ?? '').split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+  if (!firstLine) return 'unknown';
+  const command = firstLine.split(/[\\/]/).pop().toLowerCase().replace(/\.exe$/, '');
+  if (command.includes('claude')) return 'claude-code';
+  if (command.includes('codex')) return 'codex';
+  if (command.includes('zcode')) return 'zcode';
+  return /^[a-z0-9][a-z0-9._-]{0,63}$/.test(command) ? command : 'unknown';
+}
+
+function readParentProcess({ platform, pid }) {
+  const options = {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'ignore'],
+    timeout: 2_000,
+    windowsHide: true,
+  };
+  if (platform === 'win32') {
+    return execFileSync('powershell.exe', [
+      '-NoLogo',
+      '-NoProfile',
+      '-NonInteractive',
+      '-Command',
+      `(Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}").Name`,
+    ], options);
+  }
+  return execFileSync('ps', ['-o', 'comm=', '-p', String(pid)], options);
+}
+
+export function detectOrchestrator({
+  env = process.env,
+  platform = process.platform,
+  parentPid = process.ppid,
+  readParent = readParentProcess,
+} = {}) {
+  const explicit = explicitSource(env.DSH_ORCHESTRATOR);
+  if (explicit) return explicit;
+  if (env.CLAUDECODE || env.CLAUDE_CODE_ENTRYPOINT) return 'claude-code';
+  if (!Number.isInteger(parentPid) || parentPid < 1) return 'unknown';
+  try {
+    return classifyParent(readParent({ platform, pid: parentPid }));
+  } catch {
+    return 'unknown';
+  }
+}

package/src/readiness-matrix.mjs

@@ -26,9 +26,10 @@ const TARGET_ROWS = Object.freeze([
   ['linux_deterministic', 'ci'],
   ['windows_regressions', 'ci'],
   ['macos_smoke', 'ci'],
-  ['hub_compatibility', 'live-runtime'],
-  ['provider_catalog', 'live-runtime'],
-  ['deepseek_flash', 'real-execution'],
+  ['hub_compatibility', 'live-runtime'],
+  ['provider_catalog', 'live-runtime'],
+  ['model_execution', 'real-execution'],
+  ['deepseek_flash', 'real-execution'],
   ['deepseek_pro', 'real-execution'],
   ['opencode_go_mimo_qwen', 'real-execution'],
   ['reviewer_pipeline', 'real-execution'],

package/src/runtime-identity.mjs

@@ -8,7 +8,7 @@
 // Keep this module pure and dependency-free so Hub, MCP and tests all use the
 // exact same compatibility rules.
 
-export const RUNTIME_VERSION = '0.5.1';
+export const RUNTIME_VERSION = '0.5.3';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([

package/src/server.mjs

@@ -26,8 +26,9 @@ import { buildReviewTask } from './information-flow.mjs';
 import { projectWorkflowView } from './job-contracts.mjs';
 import { loadRoleProfiles, resolveRoleProfile } from './role-profiles.mjs';
 import { loadWorkspaceContexts, resolveWorkspaceContext, buildWorkspaceTask, addContextReferences, isSafeBranchName } from './workspace-context.mjs';
-import { buildExtensionContract } from './extension-contract.mjs';
-import { assessWorkspaceReadiness } from './workspace-readiness.mjs';
+import { buildExtensionContract } from './extension-contract.mjs';
+import { assessWorkspaceReadiness } from './workspace-readiness.mjs';
+import { detectOrchestrator } from './orchestrator.mjs';
 
 const server = new McpServer({ name: 'dsh-crew', version: RUNTIME_VERSION });
 
@@ -44,10 +45,11 @@ const workspaceSchema = z.object({
   branch: z.string().refine(isSafeBranchName, 'invalid git branch name').optional(),
   worktree: z.enum(['auto', 'existing', 'none']).optional(),
 }).optional().describe('Per-job workspace overrides. auto isolates coding Workers; existing/none use the supplied workspace.');
-const constraintsSchema = z.object({
-  timeout_seconds: z.number().int().positive().max(7200).optional(),
-  allow_fallback: z.boolean().optional(),
-}).optional().describe('Per-job constraints override profile and session defaults.');
+const constraintsSchema = z.object({
+  timeout_seconds: z.number().int().positive().max(7200).optional(),
+  allow_fallback: z.boolean().optional(),
+  allow_no_changes: z.boolean().optional().describe('Explicitly allow a verified read-only or analysis job to succeed with zero workspace changes.'),
+}).optional().describe('Per-job constraints override profile and session defaults.');
 
 // Session-level configuration. This MCP server process lives exactly as long
 // as one Claude Code / Codex session, so plain memory IS session scope.
@@ -123,19 +125,7 @@ function text(obj) {
   return { content: [{ type: 'text', text: typeof payload === 'string' ? payload : JSON.stringify(payload, null, 2) }] };
 }
 
-function detectOrchestrator() {
-  if (process.env.CLAUDECODE || process.env.CLAUDE_CODE_ENTRYPOINT) return 'claude-code';
-  try {
-    const { execSync } = require('node:child_process');
-    const comm = execSync(`ps -o comm= -p ${process.ppid}`, { encoding: 'utf8' }).trim().toLowerCase();
-    if (comm.includes('claude')) return 'claude-code';
-    if (comm.includes('codex')) return 'codex';
-    return comm.split('/').pop() || 'unknown';
-  } catch { return 'unknown'; }
-}
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-const ORCHESTRATOR = detectOrchestrator();
+const ORCHESTRATOR = detectOrchestrator();
 
 function policyRejection(decision) {
   return text({
@@ -232,9 +222,10 @@ function prepareDispatch({ task, role, tier, legacy_tier, effort, cwd, timeout_s
       profile_id: resolvedProfile.profile_id,
       requested_isolation: requestedIsolation,
       workspace_branch: workspaceOverride?.branch ?? withRefs.context?.default_branch ?? null,
-      timeout_seconds: effectiveTimeout,
-      allow_fallback: constraints?.allow_fallback ?? profileValue.fallback,
-      routing: profileValue.routing,
+      timeout_seconds: effectiveTimeout,
+      allow_fallback: constraints?.allow_fallback ?? profileValue.fallback,
+      allow_no_changes: constraints?.allow_no_changes === true,
+      routing: profileValue.routing,
       review_strictness: profileValue.review_strictness,
       workspace_context: withRefs.context,
     },
@@ -333,10 +324,12 @@ async function buildConfigReport() {
   const hubCompatibility = await hubStatus({ force: true });
   let effectiveWorkerProvider = null;
   let effectiveWorkerSelection = { flash: null, pro: null };
-  let providerResolutionError;
-  let providerCatalogChecked = false;
-  let providerCatalogBody = null;
-  const workerProviderMode = globalConfig.worker_provider_mode ?? 'deepseek-official';
+  let providerResolutionError;
+  let providerCatalogChecked = false;
+  let providerCatalogBody = null;
+  let hubJobsChecked = false;
+  let hubJobsBody = null;
+  const workerProviderMode = globalConfig.worker_provider_mode ?? 'deepseek-official';
   if (workerProviderMode === 'deepseek-official') {
     effectiveWorkerSelection = {
       flash: { provider: 'deepseek-official', model: 'deepseek-v4-flash', source: 'legacy-strict' },
@@ -366,16 +359,27 @@ async function buildConfigReport() {
       providerCatalogChecked = true;
       providerResolutionError = err?.message ?? String(err);
     }
-  } else if (hubCompatibility.reachable) {
-    providerResolutionError = hubCompatibilityMessage(hubCompatibility);
-  }
-  effectiveWorkerProvider = effectiveWorkerSelection.flash?.provider ?? null;
-  const readinessMatrix = buildConfigReadinessMatrix({
+  } else if (hubCompatibility.reachable) {
+    providerResolutionError = hubCompatibilityMessage(hubCompatibility);
+  }
+  if (hubCompatibility.compatible) {
+    try {
+      hubJobsChecked = true;
+      const jobsRes = await fetch(`${globalConfig.hub_url}/_dsh/dsh-crew/jobs`, { signal: AbortSignal.timeout(800) });
+      hubJobsBody = await jobsRes.json();
+    } catch {
+      hubJobsChecked = true;
+    }
+  }
+  effectiveWorkerProvider = effectiveWorkerSelection.flash?.provider ?? null;
+  const readinessMatrix = buildConfigReadinessMatrix({
     hubCompatibility,
     workerProviderMode,
-    providerCatalogChecked,
-    providerCatalogBody,
-  });
+    providerCatalogChecked,
+    providerCatalogBody,
+    hubJobsChecked,
+    hubJobsBody,
+  });
   const roleProfiles = loadRoleProfiles();
   const workspaceReadiness = await assessWorkspaceReadiness({ cwd: process.cwd() });
   const extensionContract = buildExtensionContract({

package/src/workflow-runtime.mjs

@@ -15,7 +15,7 @@
 // appear here.
 
 import { resolveModelPolicy, shouldAutoReview, getRoleState } from './policy.mjs';
-import { buildOutcome, decideNextStep, JOB_PHASES, canTransition } from './workflow.mjs';
+import { applyWorkspaceEvidence, buildOutcome, decideNextStep, JOB_PHASES, canTransition } from './workflow.mjs';
 import { parseDeliveryReport } from './delivery.mjs';
 import { classifyFailure } from './failure-classification.mjs';
 import { createCanonicalJobEvent } from './job-contracts.mjs';
@@ -70,17 +70,6 @@ function mutationDetected(before, after) {
   return after.fingerprint != null && before.fingerprint !== after.fingerprint;
 }
 
-function deliveryClaimsChanges(outcome) {
-  return Array.isArray(outcome?.changes) && outcome.changes.length > 0;
-}
-
-function workspaceEvidenceOK(outcome, candidate) {
-  if (!candidate) return true;
-  const hasChanges = Array.isArray(candidate.changed_files) && candidate.changed_files.length > 0;
-  if (outcome?.execution_status !== 'completed') return true;
-  return !deliveryClaimsChanges(outcome) || hasChanges;
-}
-
 function sumUsage(attempts) {
   const tokens = { input: 0, output: 0, reasoning: 0 };
   for (const a of attempts) {
@@ -181,9 +170,10 @@ export function createWorkflowRuntime(adapters, {
       requested_isolation: spec.requested_isolation ?? null,
       workspace_branch: spec.workspace_branch ?? null,
       timeout_seconds: spec.timeout_seconds ?? null,
-      profile_id: spec.profile_id ?? null,
-      allow_fallback: spec.allow_fallback !== false,
-      routing: spec.routing ?? 'auto',
+      profile_id: spec.profile_id ?? null,
+      allow_fallback: spec.allow_fallback !== false,
+      allow_no_changes: spec.allow_no_changes === true,
+      routing: spec.routing ?? 'auto',
       review_strictness: spec.review_strictness ?? null,
       workspace_context: spec.workspace_context ? { ...spec.workspace_context } : null,
       effort: spec.effort ?? 'max',
@@ -385,14 +375,17 @@ export function createWorkflowRuntime(adapters, {
           failJob(job, Object.assign(new Error(ar.error ?? 'infrastructure failure'), { code: WORKFLOW_ERROR_CODES.ATTEMPT_INFRA_FAILURE }));
           return;
         }
-        const outcome = ar.outcome ?? buildOutcome({
+        let outcome = ar.outcome ?? buildOutcome({
           result: ar.result ?? '',
           stopReason: ar.stopReason,
           executionStatus: ar.status === 'done' ? 'completed' : 'failed',
         });
         transition(job, JOB_PHASES.VERIFYING, `attempt ${attempt} complete`);
 
-        // Capture the latest candidate after every attempt. Capture failure is
+        let workspaceEvidenceAvailable = false;
+        let workspaceHasChanges = false;
+
+        // Capture the latest candidate after every attempt. Capture failure is
         // not allowed to delete the only recoverable state: retain the worktree
         // and preserve the worker business result, while surfacing the warning.
         if (alloc?.ok && alloc.isolation === 'worktree') {
@@ -402,17 +395,23 @@ export function createWorkflowRuntime(adapters, {
             job.retain_workspace = true;
             job.candidate = null;
             job.events.push({ at: clock(), phase: job.phase, type: 'candidate/failed', attempt, message: 'candidate capture failed; worktree retained for recovery' });
-          } else {
-            job.candidate = candidate;
-            attemptView.candidate_fingerprint = candidate.fingerprint ?? null;
-            outcome.workspace_evidence_ok = workspaceEvidenceOK(outcome, candidate);
-            if (candidate.complete === false || candidate.replayable === false) {
+          } else {
+            job.candidate = candidate;
+            attemptView.candidate_fingerprint = candidate.fingerprint ?? null;
+            workspaceEvidenceAvailable = true;
+            workspaceHasChanges = Array.isArray(candidate.changed_files) && candidate.changed_files.length > 0;
+            if (candidate.complete === false || candidate.replayable === false) {
               job.retain_workspace = true;
               job.events.push({ at: clock(), phase: job.phase, type: 'candidate/incomplete', attempt, message: 'candidate is not fully replayable; worktree retained' });
             }
-          }
-        }
-        job.outcome = outcome;
+          }
+        }
+        outcome = applyWorkspaceEvidence(outcome, {
+          evidenceAvailable: workspaceEvidenceAvailable,
+          hasChanges: workspaceHasChanges,
+          allowNoChanges: job.allow_no_changes,
+        });
+        job.outcome = outcome;
 
         const reviewRequested = !isReviewJob && shouldAutoReview(config);
         const reviewerAuto = getRoleState(config, 'reviewer') !== 'disabled';
@@ -580,8 +579,9 @@ export function createWorkflowRuntime(adapters, {
       current_model: job.attempts[job.attempts.length - 1]?.model ?? null,
       model_class_hint: job.model_class_hint,
       source: job.source,
-      profile_id: job.profile_id,
-      routing: job.routing,
+      profile_id: job.profile_id,
+      allow_no_changes: job.allow_no_changes,
+      routing: job.routing,
       workspace_context: job.workspace_context ? { ...job.workspace_context } : null,
       workspace_branch: job.workspace_branch,
       timeout_seconds: job.timeout_seconds,