@ran-sh/dsh-crew 0.3.8 → 0.4.1

package/src/role-profiles.mjs

@@ -0,0 +1,107 @@
+// Versioned, narrow Worker/Reviewer profiles. Profiles configure one DSH
+// delegation; they are not general Agent personas and never contain prompts or
+// credentials.
+
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+export const ROLE_PROFILE_SCHEMA_VERSION = 1;
+export const DEFAULT_ROLE_PROFILES = Object.freeze({
+  'worker-default': Object.freeze({
+    role: 'worker', routing: 'auto', isolation: 'worktree', fallback: true,
+    timeout_seconds: 1800, review_strictness: 'standard',
+  }),
+  'reviewer-default': Object.freeze({
+    role: 'reviewer', routing: 'stable', isolation: 'readonly', fallback: false,
+    timeout_seconds: 1800, review_strictness: 'strict',
+  }),
+});
+
+const ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const ROLES = new Set(['worker', 'reviewer']);
+const ROUTING = new Set(['auto', 'priority', 'stable']);
+const ISOLATION = new Set(['worktree', 'readonly', 'shared']);
+const STRICTNESS = new Set(['standard', 'strict']);
+
+function normalizeProfile(id, raw) {
+  if (!ID.test(id) || !raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+  if (!ROLES.has(raw.role)) return null;
+  const base = DEFAULT_ROLE_PROFILES[`${raw.role}-default`];
+  const routing = raw.routing ?? base.routing;
+  const isolation = raw.isolation ?? base.isolation;
+  const reviewStrictness = raw.review_strictness ?? base.review_strictness;
+  const timeout = raw.timeout_seconds ?? base.timeout_seconds;
+  if (!ROUTING.has(routing) || !ISOLATION.has(isolation) || !STRICTNESS.has(reviewStrictness)) return null;
+  if (!Number.isInteger(timeout) || timeout < 1 || timeout > 7200) return null;
+  if (raw.fallback !== undefined && typeof raw.fallback !== 'boolean') return null;
+  return {
+    role: raw.role,
+    routing,
+    isolation,
+    fallback: raw.fallback ?? base.fallback,
+    timeout_seconds: timeout,
+    review_strictness: reviewStrictness,
+  };
+}
+
+export function roleProfilesFile({ home = homedir() } = {}) {
+  return join(home, '.config', 'dsh-crew', 'profiles.json');
+}
+
+export function loadRoleProfiles({ home = homedir(), file = roleProfilesFile({ home }) } = {}) {
+  if (!existsSync(file)) {
+    return { schema_version: ROLE_PROFILE_SCHEMA_VERSION, ok: true, source: 'defaults', profiles: { ...DEFAULT_ROLE_PROFILES }, errors: [] };
+  }
+  let raw;
+  try { raw = JSON.parse(readFileSync(file, 'utf8')); } catch {
+    return { schema_version: ROLE_PROFILE_SCHEMA_VERSION, ok: false, source: 'file', profiles: { ...DEFAULT_ROLE_PROFILES }, errors: [{ code: 'PROFILE_FILE_INVALID' }] };
+  }
+  return parseRoleProfiles(raw);
+}
+
+function parseRoleProfiles(raw) {
+  const errors = [];
+  const profiles = { ...DEFAULT_ROLE_PROFILES };
+  if (raw?.schema_version !== ROLE_PROFILE_SCHEMA_VERSION || !raw.profiles || typeof raw.profiles !== 'object' || Array.isArray(raw.profiles)) {
+    return { schema_version: ROLE_PROFILE_SCHEMA_VERSION, ok: false, source: 'file', profiles, errors: [{ code: 'PROFILE_FILE_INVALID' }] };
+  }
+  for (const [id, value] of Object.entries(raw.profiles)) {
+    if (id in DEFAULT_ROLE_PROFILES) {
+      const normalized = normalizeProfile(id, value);
+      if (!normalized || JSON.stringify(normalized) !== JSON.stringify(DEFAULT_ROLE_PROFILES[id])) {
+        errors.push({ code: 'PROFILE_DEFAULT_RESERVED', profile_id: id });
+      }
+      continue;
+    }
+    const profile = normalizeProfile(id, value);
+    if (!profile) errors.push({ code: 'PROFILE_INVALID', profile_id: ID.test(id) ? id : '<invalid>' });
+    else profiles[id] = profile;
+  }
+  return { schema_version: ROLE_PROFILE_SCHEMA_VERSION, ok: errors.length === 0, source: 'file', profiles, errors: errors.slice(0, 32) };
+}
+
+export function saveRoleProfiles(document, { home = homedir(), file = roleProfilesFile({ home }) } = {}) {
+  const parsed = parseRoleProfiles(document);
+  if (!parsed.ok) return parsed;
+  const custom = Object.fromEntries(Object.entries(parsed.profiles).filter(([id]) => !(id in DEFAULT_ROLE_PROFILES)));
+  const payload = { schema_version: ROLE_PROFILE_SCHEMA_VERSION, profiles: custom };
+  mkdirSync(dirname(file), { recursive: true });
+  const temp = `${file}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    writeFileSync(temp, `${JSON.stringify(payload, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(temp, file);
+  } catch (error) {
+    rmSync(temp, { force: true });
+    return { ...parsed, ok: false, errors: [{ code: 'PROFILE_FILE_WRITE_FAILED' }], error_code: 'PROFILE_FILE_WRITE_FAILED' };
+  }
+  return { ...parsed, source: 'file' };
+}
+
+export function resolveRoleProfile(registry, profileId, role = 'worker') {
+  const id = profileId ?? `${role}-default`;
+  const profile = registry?.profiles?.[id];
+  if (!profile) return { ok: false, code: 'PROFILE_NOT_FOUND', profile_id: id };
+  if (profile.role !== role) return { ok: false, code: 'PROFILE_ROLE_MISMATCH', profile_id: id, expected_role: role };
+  return { ok: true, profile_id: id, profile: { ...profile } };
+}

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.3.8';
+export const RUNTIME_VERSION = '0.4.1';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([
@@ -21,6 +21,11 @@ export const HUB_CAPABILITIES = Object.freeze([
   'model-catalog',
   'presets',
   'config',
+  'canonical-events',
+  'evidence',
+  'profiles',
+  'workspace-context',
+  'extension-contract',
 ]);
 
 // Capabilities the current MCP workflow depends on for full Hub execution.

package/src/server.mjs

@@ -6,7 +6,7 @@ import { z } from 'zod';
 import { startJob, waitJob, cancelJob, listJobs, getJob, jobView } from './jobs.mjs';
 import { hubStatus, hub } from './hub-client.mjs';
 import { hubCompatibilityMessage, resolveHubExecutionMode } from './hub-compatibility.mjs';
-import { RUNTIME_VERSION } from './runtime-identity.mjs';
+import { RUNTIME_VERSION, getHubRuntimeIdentity } from './runtime-identity.mjs';
 import { resolveWorkerModel } from './model-routing.mjs';
 import { runtimeActivationMetadata } from './runtime-controls.mjs';
 import { buildConfigReadinessMatrix } from './config-readiness.mjs';
@@ -22,12 +22,32 @@ import {
   shouldAutoReview,
 } from './policy.mjs';
 import { buildMcpWorkflowRuntime } from './mcp-runtime.mjs';
+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';
 
 const server = new McpServer({ name: 'dsh-crew', version: RUNTIME_VERSION });
 
 const tierSchema = z.enum(['flash', 'pro']).optional().describe('Legacy worker tier (compatibility only): Flash/Pro now act as a model-class hint, not a role. Prefer role=worker / role=reviewer; the backend resolves the actual provider/model from the Model Policy.');
 const roleSchema = z.enum(['worker', 'reviewer']).optional().describe('Dispatch role: worker executes implementation / fixes / tests / search; reviewer independently reviews a completed implementation. A coding request defaults to worker; reviewer runs on explicit request or via the automatic review workflow.');
 const effortSchema = z.enum(['off', 'high', 'max']).optional().describe('Reasoning effort for the worker. Omit to use the session default.');
+const detailSchema = z.enum(['compact', 'full']).default('compact').describe('compact returns the bounded Result Contract; full explicitly includes raw workflow/candidate details for debugging.');
+const profileSchema = z.string().max(64).optional().describe('Versioned Worker/Reviewer profile id; defaults by role.');
+const workspaceIdSchema = z.string().max(64).optional().describe('Workspace Context id from Crew-owned workspaces.json.');
+const contextRefsSchema = z.array(z.string().max(256)).max(32).optional().describe('Additional workspace-relative instruction references; contents are not copied.');
+const clientJobIdSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/).optional().describe('Optional caller id echoed in events and evidence; Crew still assigns its own workflow id.');
+const workspaceSchema = z.object({
+  repo_root: z.string().optional(),
+  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.');
 
 // Session-level configuration. This MCP server process lives exactly as long
 // as one Claude Code / Codex session, so plain memory IS session scope.
@@ -144,29 +164,6 @@ async function resolveMode() {
   return decision.mode;
 }
 
-/** Reviewer prompt built only from structured outcome + sanitized candidate. */
-function buildReviewTask(task, view) {
-  const parts = [
-    'You are the automatic reviewer of a completed worker implementation. REVIEW ONLY: inspect the candidate and report findings. Do NOT modify any files unless the user explicitly asks for fixes.',
-    '',
-    'Original task:',
-    task,
-  ];
-  const o = view?.outcome;
-  if (o) {
-    parts.push('', 'Worker outcome:');
-    parts.push(`task_status=${o.task_status} tests_status=${o.tests_status ?? 'none'} delivery=${o.delivery?.complete ? 'complete' : 'incomplete'}`);
-  }
-  const c = view?.candidate;
-  if (c) {
-    parts.push('', 'Candidate changed files:', Array.isArray(c.changed_files) && c.changed_files.length ? c.changed_files.join('\n') : '(none)');
-    if (c.base_revision) parts.push(`Base revision: ${c.base_revision}`);
-    if (c.patch) parts.push('', 'Candidate patch (sanitized):', String(c.patch).slice(0, 8000));
-  }
-  parts.push('', 'Report: 1) does the implementation satisfy the task, 2) concrete issues (bugs, style, risks), 3) suggested fixes. End your message with ## Review Findings / ## Evidence / ## Risks / ## Verdict (approved | needs changes | rejected).');
-  return parts.join('\n');
-}
-
 const workflowRuntime = buildMcpWorkflowRuntime({
   getSessionConfig: () => sessionConfig,
   resolveMode,
@@ -176,61 +173,107 @@ const workflowRuntime = buildMcpWorkflowRuntime({
   attemptTimeoutMs: () => (sessionConfig.default_timeout_seconds ?? 1800) * 1000,
 });
 
-server.registerTool('dsh_run_worker', {
-  title: 'Run DSH worker (blocking)',
-  description: 'Delegate a task to a DSH (DeepSeek Harness) coding agent and wait for its final result. The worker is a full DSH agent with its own tools and sandbox. Pass role=worker for implementation and role=reviewer for an independent review pass. Disabled roles are refused by the DSH Crew policy; Manual roles only run when explicitly requested. Blocks until the worker finishes.',
-  inputSchema: {
-    task: z.string().describe('Full task description for the worker, self-contained'),
-    role: roleSchema,
-    tier: tierSchema,
-    legacy_tier: tierSchema.describe('Legacy model-class hint (flash | pro), forwarded verbatim by deprecated ds-flash/ds-pro aliases; only influences which model class backs a worker role, never the role gate'),
-    effort: effortSchema,
-    cwd: z.string().optional().describe('Workspace directory for the worker (defaults to current project)'),
-    timeout_seconds: z.number().int().positive().max(7200).optional(),
-  },
-}, async ({ task, role, tier, legacy_tier, effort, cwd, timeout_seconds }) => {
-  if (!sessionConfig.enabled) return dispatchDisabled();
+function dispatchError(code, details = {}) {
+  return { ok: false, response: text({ error: details.error ?? code, code, ...details }) };
+}
+
+function prepareDispatch({ task, role, tier, legacy_tier, effort, cwd, timeout_seconds, profile, workspace_id, context_refs, job_id, workspace: workspaceOverride, constraints }) {
   const globalConfig = currentGlobalConfig();
-  const hint = resolveRoleTierHint(role, legacy_tier ?? tier);
-  if (!hint.ok) return text({ error: hint.error, code: hint.code, note: 'Resolve the conflict on the caller side: pass only role, or only tier.' });
+  const profileRegistry = loadRoleProfiles();
+  if (!profileRegistry.ok) return dispatchError('PROFILE_FILE_INVALID', { errors: profileRegistry.errors });
+  const profileRole = profile ? profileRegistry.profiles?.[profile]?.role : undefined;
+  const requestedRole = role ?? profileRole;
+  const hint = resolveRoleTierHint(requestedRole, legacy_tier ?? tier);
+  if (!hint.ok) return dispatchError(hint.code, { error: hint.error });
   const effRole = hint.role;
+  const resolvedProfile = resolveRoleProfile(profileRegistry, profile, effRole);
+  if (!resolvedProfile.ok) return dispatchError(resolvedProfile.code, resolvedProfile);
+
   let effTier;
   let decision;
-  if (role === undefined) {
+  if (requestedRole === undefined) {
     decision = chooseDefaultTier(globalConfig, legacy_tier ?? tier, sessionConfig);
-    if (!decision.ok) return policyRejection(decision);
+    if (!decision.ok) return { ok: false, response: policyRejection(decision) };
     effTier = decision.tier;
   } else {
     decision = canDispatchRole(globalConfig, effRole, true, sessionConfig);
-    if (!decision.ok) return policyRejection(decision);
+    if (!decision.ok) return { ok: false, response: policyRejection(decision) };
     if (effRole === 'reviewer') effTier = 'pro';
     else if (legacy_tier !== undefined) effTier = legacy_tier;
     else if (tier !== undefined) effTier = tier;
     else { const slot = chooseDefaultTier(globalConfig, undefined, sessionConfig); effTier = slot.ok ? slot.tier : 'flash'; }
   }
-  const workDir = cwd ?? process.cwd();
-  const e = effort ?? sessionConfig.default_effort;
-  const timeout = timeout_seconds ?? sessionConfig.default_timeout_seconds;
 
-  const spec = {
+  const workDir = workspaceOverride?.repo_root ?? cwd ?? process.cwd();
+  const workspace = resolveWorkspaceContext(loadWorkspaceContexts(), { workspace_id, cwd: workDir });
+  if (!workspace.ok) return dispatchError(workspace.code, workspace);
+  const withRefs = addContextReferences(workspace.context, context_refs, { cwd: workDir });
+  if (!withRefs.ok) return dispatchError(withRefs.code);
+  const profileValue = resolvedProfile.profile;
+  const effectiveTimeout = constraints?.timeout_seconds ?? timeout_seconds ?? profileValue.timeout_seconds ?? sessionConfig.default_timeout_seconds;
+  const requestedIsolation = workspaceOverride?.worktree === 'auto'
+    ? 'worktree'
+    : workspaceOverride?.worktree === 'existing' || workspaceOverride?.worktree === 'none'
+      ? 'shared'
+      : profileValue.isolation;
+  return {
+    ok: true,
     role: effRole,
-    delivery: effRole === 'reviewer' ? 'review' : 'coding',
-    model_class_hint: effTier,
-    task,
-    cwd: workDir,
-    effort: e,
-    source: ORCHESTRATOR,
+    timeout: effectiveTimeout,
+    spec: {
+      client_job_id: job_id ?? null,
+      role: effRole,
+      delivery: effRole === 'reviewer' ? 'review' : 'coding',
+      model_class_hint: effTier,
+      task: buildWorkspaceTask(task, withRefs.context),
+      cwd: workDir,
+      effort: effort ?? sessionConfig.default_effort,
+      source: ORCHESTRATOR,
+      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,
+      review_strictness: profileValue.review_strictness,
+      workspace_context: withRefs.context,
+    },
   };
-  const wf = workflowRuntime.start(spec);
-  await workflowRuntime.wait(wf.id, timeout * 1000);
+}
+
+server.registerTool('dsh_run_worker', {
+  title: 'Run DSH worker (blocking)',
+  description: 'Delegate a task to a DSH (DeepSeek Harness) coding agent and wait for its final result. The worker is a full DSH agent with its own tools and sandbox. Pass role=worker for implementation and role=reviewer for an independent review pass. Disabled roles are refused by the DSH Crew policy; Manual roles only run when explicitly requested. Blocks until the worker finishes.',
+  inputSchema: {
+    task: z.string().describe('Full task description for the worker, self-contained'),
+    role: roleSchema,
+    tier: tierSchema,
+    legacy_tier: tierSchema.describe('Legacy model-class hint (flash | pro), forwarded verbatim by deprecated ds-flash/ds-pro aliases; only influences which model class backs a worker role, never the role gate'),
+    effort: effortSchema,
+    cwd: z.string().optional().describe('Workspace directory for the worker (defaults to current project)'),
+    timeout_seconds: z.number().int().positive().max(7200).optional(),
+    job_id: clientJobIdSchema,
+    workspace: workspaceSchema,
+    constraints: constraintsSchema,
+    profile: profileSchema,
+    workspace_id: workspaceIdSchema,
+    context_refs: contextRefsSchema,
+    detail: detailSchema,
+  },
+}, async ({ task, role, tier, legacy_tier, effort, cwd, timeout_seconds, profile, workspace_id, context_refs, job_id, workspace, constraints, detail }) => {
+  if (!sessionConfig.enabled) return dispatchDisabled();
+  const prepared = prepareDispatch({ task, role, tier, legacy_tier, effort, cwd, timeout_seconds, profile, workspace_id, context_refs, job_id, workspace, constraints });
+  if (!prepared.ok) return prepared.response;
+  const wf = workflowRuntime.start(prepared.spec);
+  await workflowRuntime.wait(wf.id, prepared.timeout * 1000);
   const view = workflowRuntime.get(wf.id, { withResult: true });
   if (view.status === 'running') {
-    return text({ ...view, note: `still running after ${timeout}s; poll with dsh_worker_result`, status: 'running' });
+    return text({ ...projectWorkflowView(view, { detail }), note: `still running after ${prepared.timeout}s; poll with dsh_worker_result`, status: 'running' });
   }
   if (view.phase === 'failed') {
-    return text({ ...view, note: 'workflow failed — see error / error_code.', status: 'failed' });
+    return text({ ...projectWorkflowView(view, { detail }), note: 'workflow failed — see error / error_code.', status: 'failed' });
   }
-  return text({ ...view, note: effRole === 'reviewer' ? 'review complete' : 'workflow complete' });
+  return text({ ...projectWorkflowView(view, { detail }), note: prepared.role === 'reviewer' ? 'review complete' : 'workflow complete' });
 });
 
 server.registerTool('dsh_worker_config', {
@@ -333,6 +376,21 @@ async function buildConfigReport() {
     providerCatalogChecked,
     providerCatalogBody,
   });
+  const roleProfiles = loadRoleProfiles();
+  const workspaceReadiness = await assessWorkspaceReadiness({ cwd: process.cwd() });
+  const extensionContract = buildExtensionContract({
+    config: {
+      ...globalConfig,
+      subagents_enabled: sessionConfig.enabled !== false && globalConfig.subagents_enabled !== false,
+      worker_state: globalConfig.worker_state,
+      review_state: globalConfig.review_state,
+      escalate_on_failure: sessionConfig.escalate_on_failure ?? legacy.escalate_on_failure,
+    },
+    readinessMatrix,
+    workspace: workspaceReadiness,
+    profiles: roleProfiles,
+    runtime: getHubRuntimeIdentity(),
+  });
   return {
     enabled: sessionConfig.enabled,
     default_tier: sessionConfig.default_tier ?? legacy.default_tier,
@@ -371,6 +429,8 @@ async function buildConfigReport() {
     runtime_controls: runtimeControls,
     activation_boundaries: activationBoundaries,
     readiness_matrix: readinessMatrix,
+    role_profiles: roleProfiles,
+    extension_contract: extensionContract,
     hub_reachable: hubCompatibility.reachable,
     hub_compatible: hubCompatibility.compatible,
     hub_compatibility: hubCompatibility,
@@ -387,39 +447,18 @@ server.registerTool('dsh_spawn_worker', {
     legacy_tier: tierSchema.describe('Legacy model-class hint (flash | pro) — only influences the model class backing a worker role, never the role gate'),
     effort: effortSchema,
     cwd: z.string().optional(),
+    job_id: clientJobIdSchema,
+    workspace: workspaceSchema,
+    constraints: constraintsSchema,
+    profile: profileSchema,
+    workspace_id: workspaceIdSchema,
+    context_refs: contextRefsSchema,
   },
-}, async ({ task, role, tier, legacy_tier, effort, cwd }) => {
+}, async ({ task, role, tier, legacy_tier, effort, cwd, profile, workspace_id, context_refs, job_id, workspace, constraints }) => {
   if (!sessionConfig.enabled) return dispatchDisabled();
-  const globalConfig = currentGlobalConfig();
-  const hint = resolveRoleTierHint(role, legacy_tier ?? tier);
-  if (!hint.ok) return text({ error: hint.error, code: hint.code, note: 'Resolve the conflict on the caller side: pass only role, or only tier.' });
-  const effRole = hint.role;
-  let effTier;
-  let decision;
-  if (role === undefined) {
-    decision = chooseDefaultTier(globalConfig, legacy_tier ?? tier, sessionConfig);
-    if (!decision.ok) return policyRejection(decision);
-    effTier = decision.tier;
-  } else {
-    decision = canDispatchRole(globalConfig, effRole, true, sessionConfig);
-    if (!decision.ok) return policyRejection(decision);
-    if (effRole === 'reviewer') effTier = 'pro';
-    else if (legacy_tier !== undefined) effTier = legacy_tier;
-    else if (tier !== undefined) effTier = tier;
-    else { const slot = chooseDefaultTier(globalConfig, undefined, sessionConfig); effTier = slot.ok ? slot.tier : 'flash'; }
-  }
-  const workDir = cwd ?? process.cwd();
-  const e = effort ?? sessionConfig.default_effort;
-  const spec = {
-    role: effRole,
-    delivery: effRole === 'reviewer' ? 'review' : 'coding',
-    model_class_hint: effTier,
-    task,
-    cwd: workDir,
-    effort: e,
-    source: ORCHESTRATOR,
-  };
-  const wf = workflowRuntime.start(spec);
+  const prepared = prepareDispatch({ task, role, tier, legacy_tier, effort, cwd, profile, workspace_id, context_refs, job_id, workspace, constraints });
+  if (!prepared.ok) return prepared.response;
+  const wf = workflowRuntime.start(prepared.spec);
   return text({ ...workflowRuntime.get(wf.id), workflow_id: wf.id, note: 'started in background; poll with dsh_worker_status / dsh_worker_result' });
 });
 
@@ -437,41 +476,45 @@ server.registerTool('dsh_worker_result', {
   inputSchema: {
     job_id: z.string(),
     wait_seconds: z.number().int().min(0).max(7200).default(0).describe('0 = return current state immediately'),
+    after_sequence: z.number().int().min(0).default(0).describe('Return canonical events after this cursor for incremental watch.'),
+    detail: detailSchema,
   },
-}, async ({ job_id, wait_seconds }) => {
+}, async ({ job_id, wait_seconds, after_sequence, detail }) => {
   if (job_id.startsWith('wf-')) {
     if (wait_seconds > 0) await workflowRuntime.wait(job_id, wait_seconds * 1000);
     const view = workflowRuntime.get(job_id, { withResult: true });
     if (!view) return text({ error: `no such workflow: ${job_id}` });
-    return text(view);
+    return text(projectWorkflowView(view, { detail, afterSequence: after_sequence }));
   }
   if (job_id.startsWith('hub-')) {
     const status = await hubStatus();
     if (!status.compatible) return text({ error: hubCompatibilityMessage(status), code: status.code, hub_compatibility: status });
-    return text(await hub.get(job_id, wait_seconds).catch((e) => ({ error: e.message })));
+    const view = await hub.get(job_id, wait_seconds).catch((e) => ({ error: e.message }));
+    return text(projectWorkflowView(view, { detail, afterSequence: after_sequence }));
   }
   if (!getJob(job_id)) return text({ error: `no such job: ${job_id} (expected a wf- workflow id)` });
   const job = await waitJob(job_id, wait_seconds > 0 ? wait_seconds * 1000 : 1);
-  return text(jobView(job, { withResult: true }));
+  return text(projectWorkflowView(jobView(job, { withResult: true }), { detail, afterSequence: after_sequence }));
 });
 
 server.registerTool('dsh_worker_cancel', {
   title: 'Cancel DSH worker',
   description: 'Cancel a worker workflow (stops the active attempt, never starts escalation/review, releases its worktree). Accepts workflow ids (wf-...), Hub attempt ids (hub-...) and legacy standalone ids (job-...).',
-  inputSchema: { job_id: z.string() },
-}, async ({ job_id }) => {
+  inputSchema: { job_id: z.string(), detail: detailSchema },
+}, async ({ job_id, detail }) => {
   if (job_id.startsWith('wf-')) {
     const view = await workflowRuntime.cancel(job_id);
     if (!view) return text({ error: `no such workflow: ${job_id}` });
-    return text({ ...view, note: 'cancelled' });
+    return text({ ...projectWorkflowView(view, { detail }), note: 'cancelled' });
   }
   if (job_id.startsWith('hub-')) {
     const status = await hubStatus();
     if (!status.compatible) return text({ error: hubCompatibilityMessage(status), code: status.code, hub_compatibility: status });
-    return text(await hub.cancel(job_id).catch((e) => ({ error: e.message })));
+    const view = await hub.cancel(job_id).catch((e) => ({ error: e.message }));
+    return text(projectWorkflowView(view, { detail }));
   }
   if (!getJob(job_id)) return text({ error: `no such job: ${job_id} (expected a wf- workflow id)` });
-  return text(jobView(await cancelJob(job_id), { withResult: true }));
+  return text(projectWorkflowView(jobView(await cancelJob(job_id), { withResult: true }), { detail }));
 });
 
 await server.connect(new StdioServerTransport());