@ran-sh/dsh-crew 0.3.0

package/src/jobs.mjs

@@ -0,0 +1,275 @@
+// Job manager: each job runs one dsh-jsonrpc-agent runtime via the DSH SDK.
+// Progress derived from session.event notifications; status mirrored to a
+// JSON file so the Claude Code statusline (and anything else) can render it.
+
+import { DeepSeekHarness } from '@deepseek-ai/dsh-sdk-client';
+import { readFileSync, mkdirSync, existsSync } from 'node:fs';
+import { createShardWriter } from './status-shard.mjs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { createRequire } from 'node:module';
+import { appendDeliveryInstructions, parseDeliveryReport, formatDeliveryMetadata } from './delivery.mjs';
+import { captureWorkspaceBaseline, captureWorkspaceDiff, NOT_A_GIT_REPOSITORY } from './workspace-audit.mjs';
+import { buildOutcome, JOB_PHASES } from './workflow.mjs';
+import { buildDirectSelectionTrace } from './model-routing.mjs';
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const CONFIG_DIR = join(homedir(), '.config', 'dsh-crew');
+const STATUS_FILE = join(CONFIG_DIR, 'status.json');
+const CORDIS = join(ROOT, 'worker.cordis.yml');
+
+// The worker agent entry. The pnpm .bin shim on Windows is a POSIX shell
+// script that Node spawn cannot execute (ENOENT), so we always launch
+// `node <lib/bin.js> <cordis>` via process.execPath — cross-platform.
+const requireAgents = createRequire(import.meta.url);
+let AGENT_JS = null;
+for (const spec of ['@deepseek-ai/dsh-sdk-jsonrpc-demo/bin', '@deepseek-ai/dsh-sdk-jsonrpc-demo/lib/bin.js']) {
+  try { AGENT_JS = requireAgents.resolve(spec); break; } catch {}
+}
+if (!AGENT_JS) AGENT_JS = join(ROOT, 'node_modules', '@deepseek-ai', 'dsh-sdk-jsonrpc-demo', 'lib', 'bin.js');
+
+export const TIERS = {
+  flash: { model: 'deepseek-v4-flash', label: 'V4 Flash' },
+  pro: { model: 'deepseek-v4-pro', label: 'V4 Pro' },
+};
+
+// v0.2: a job carries a dispatch role (worker | reviewer) plus its legacy
+// tier slot. The role describes who did the work; the tier is the model-class
+// slot that standalone mode falls back to (role = execution intent).
+export const ROLES = {
+  worker: { canReview: false },
+  reviewer: { canReview: true },
+};
+
+function loadDotEnv() {
+  const out = {};
+  try {
+    for (const line of readFileSync(join(CONFIG_DIR, '.env'), 'utf8').split('\n')) {
+      const m = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
+      if (m && m[2]) out[m[1]] = m[2];
+    }
+  } catch {}
+  return out;
+}
+
+const jobs = new Map();
+let nextId = 1;
+const shard = createShardWriter('mcp');
+
+function publishStatus() {
+  shard.publish([...jobs.values()].map((j) => ({
+    id: j.id, role: j.role ?? 'worker', attempt: j.attempt ?? 0, phase: j.phase ?? null, tier: j.tier, provider: j.provider, model: j.model, selection_source: j.selection_source,
+    selection_trace: j.selection_trace ?? null,
+    effort: j.effort, requested_effort: j.effort, reasoning_effort: j.reasoning_effort ?? j.effort,
+    status: j.status, source: j.source,
+    task: j.task.slice(0, 300), cwd: j.cwd, turn: j.turn, step: j.step, toolCalls: j.toolCalls,
+    currentTool: j.currentTool, tokens: j.tokens,
+    startedAt: j.startedAt, endedAt: j.endedAt,
+    delivery_complete: !!j.delivery_complete,
+    workspace_diff_available: !!j.workspaceDiff && j.workspaceDiff.kind === 'git',
+  })));
+}
+
+export function jobView(j, { withResult = false } = {}) {
+  const v = {
+    id: j.id, role: j.role ?? 'worker', attempt: j.attempt ?? 0, phase: j.phase ?? null, tier: j.tier, provider: j.provider, model: j.model, selection_source: j.selection_source,
+    selection_trace: j.selection_trace ?? null,
+    effort: j.effort, requested_effort: j.effort, reasoning_effort: j.reasoning_effort ?? j.effort,
+    status: j.status, source: j.source,
+    task: j.task.slice(0, 300), turn: j.turn, step: j.step, currentTool: j.currentTool,
+    tokens: j.tokens, toolCalls: j.toolCalls, startedAt: j.startedAt, endedAt: j.endedAt,
+    delivery_complete: !!j.delivery_complete,
+    workspace_diff_available: !!j.workspaceDiff && j.workspaceDiff.kind === 'git',
+  };
+  if (withResult) {
+    v.result = j.result; v.error = j.error; v.stopReason = j.stopReason;
+    v.delivery = j.delivery_metadata ?? null;
+    v.delivery_missing = j.delivery_missing ?? [];
+    v.outcome = j.outcome ?? null;
+    v.workspace_diff = j.workspaceDiff ?? null;
+    v.workspace_baseline_dirty = !!j.workspaceDiff?.dirtyBaseline;
+  }
+  return v;
+}
+
+export function listJobs() { return [...jobs.values()]; }
+export function getJob(id) { return jobs.get(id); }
+
+export function startJob({
+  task,
+  tier = 'flash',
+  role = 'worker',
+  attempt = 0,
+  effort = 'max',
+  cwd,
+  maxTokens = 49_152,
+  timeoutMs = 1_800_000,
+  source = 'api',
+  delivery = 'coding',
+  modelClassHint = null,
+  escalationReason = null,
+}) {
+  const tierInfo = TIERS[tier];
+  if (!tierInfo) throw new Error(`unknown tier "${tier}" (expected: ${Object.keys(TIERS).join(', ')})`);
+  if (!ROLES[role]) throw new Error(`unknown role "${role}" (expected: ${Object.keys(ROLES).join(', ')})`);
+  if (!['off', 'high', 'max'].includes(effort)) throw new Error(`unknown effort "${effort}" (expected: off, high, max)`);
+  if (!existsSync(AGENT_JS)) throw new Error(`dsh-jsonrpc-agent not installed at ${AGENT_JS}; run pnpm install in ${ROOT}`);
+  const workspace = resolve(cwd ?? process.cwd());
+  // The worker always gets the auditable Delivery Contract appended (unless it
+  // already carries one), so its final message follows ## Diff / ## Tests /
+  // ## Risks — or the review contract for reviewer-role jobs.
+  const workerPrompt = appendDeliveryInstructions(task, { tier, role, isReview: delivery === 'review' });
+  const id = `job-${nextId++}-${Date.now().toString(36)}`;
+  const dotEnv = loadDotEnv();
+  if (!process.env.DEEPSEEK_API_KEY && !dotEnv.DEEPSEEK_API_KEY) {
+    throw new Error(`DEEPSEEK_API_KEY not found in env or ${join(CONFIG_DIR, '.env')}`);
+  }
+
+  const harness = new DeepSeekHarness({
+    launch: {
+      command: process.execPath,
+      args: [AGENT_JS, CORDIS],
+      cwd: workspace,
+      env: {
+        ...process.env,
+        ...dotEnv,
+        DSH_CWD: workspace,
+        DSH_SESSION_ROOT: join(CONFIG_DIR, 'sessions'),
+        DSH_REASONING_EFFORT: effort,
+      },
+      requestTimeoutMs: timeoutMs,
+    },
+    cwd: workspace,
+    provider: 'deepseek-official',
+    model: tierInfo.model,
+    maxTokens,
+  });
+
+  const selectionTrace = buildDirectSelectionTrace({
+    role,
+    logicalAttempt: attempt,
+    modelClassHint: modelClassHint ?? tier,
+    strategy: 'standalone-legacy',
+    candidateSet: attempt > 0 ? 'escalation' : 'primary',
+    provider: 'deepseek-official',
+    model: tierInfo.model,
+    source: 'standalone-legacy',
+    escalationReason,
+  });
+  const job = {
+    id, role, attempt, tier, provider: 'deepseek-official', model: tierInfo.model, selection_source: 'standalone-legacy',
+    selection_trace: selectionTrace,
+    effort, reasoning_effort: effort, task, source, cwd: workspace,
+    prompt: workerPrompt, delivery: delivery === 'review' ? 'review' : 'coding',
+    phase: JOB_PHASES.RUNNING,
+    status: 'running', turn: 0, step: 0, currentTool: null, toolCalls: 0,
+    tokens: { input: 0, output: 0, reasoning: 0 },
+    startedAt: new Date().toISOString(), endedAt: null,
+    result: null, error: null, stopReason: null, harness,
+    delivery_complete: false, delivery_missing: [], delivery_metadata: null,
+    outcome: null,
+    workspaceDiff: null, baselinePromise: null,
+    waiters: [],
+  };
+  jobs.set(id, job);
+
+  // Read-only pre-run snapshot (async, never blocks dispatch): the audit only
+  // needs the before-state by the time the worker finishes. Non-repos degrade
+  // to { kind:'no-git' } instead of failing the job.
+  job.baselinePromise = captureWorkspaceBaseline({ cwd: workspace })
+    .catch(() => ({ kind: 'no-git', reason: NOT_A_GIT_REPOSITORY, error: 'workspace audit failed' }));
+
+  const sessionId = id;
+  const onNotification = (n) => {
+    if (n.method === 'session.status') return;
+    if (n.method !== 'session.event') return;
+    if (n.params?.sessionId && n.params.sessionId !== sessionId) return;
+    const e = n.params.event;
+    if (!e?.type) return;
+    switch (e.type) {
+      case 'step/start': job.turn = e.data?.turn ?? job.turn; job.step = e.data?.step ?? job.step; break;
+      case 'tool/call': job.currentTool = e.data?.name ?? null; job.toolCalls += 1; break;
+      case 'tool/result': job.currentTool = null; break;
+      case 'assistant/message': {
+        const u = e.data?.usage;
+        if (u) {
+          job.tokens.input += u.inputTokens ?? 0;
+          job.tokens.output += u.outputTokens ?? 0;
+          job.tokens.reasoning += u.reasoningTokens ?? 0;
+        }
+        break;
+      }
+      case 'turn/end': job.stopReason = e.data?.reason?.kind ?? null; break;
+    }
+    publishStatus();
+  };
+
+  job.promise = harness
+    .run(workerPrompt, { sessionId, onNotification })
+    .then((result) => {
+      job.result = result.finalResponse ?? '';
+      const lastEnd = [...(result.events ?? [])].reverse().find((ev) => ev?.type === 'turn/end');
+      job.stopReason = lastEnd?.data?.reason?.kind ?? job.stopReason;
+      job.status = job.stopReason === 'completed' ? 'done' : 'failed';
+      if (job.status === 'failed' && !job.error) job.error = `turn ended with reason: ${job.stopReason ?? 'unknown'}`;
+    })
+    .catch((err) => {
+      job.status = job.status === 'cancelled' ? 'cancelled' : 'failed';
+      job.error = err?.message ?? String(err);
+    })
+    .finally(async () => {
+      job.endedAt = new Date().toISOString();
+      job.currentTool = null;
+      try { await harness.close(); } catch {}
+      // Delivery completeness is separate from execution status: a job can be
+      // done yet fail to report Diff/Tests/Risks. Parse whatever final message
+      // the worker produced so the orchestrator can decide whether to accept.
+      const parsed = parseDeliveryReport(job.result ?? '');
+      job.delivery_complete = parsed.complete;
+      job.delivery_missing = parsed.missing;
+      job.delivery_metadata = formatDeliveryMetadata(parsed);
+      // Canonical structured outcome (shared workflow layer) + terminal phase.
+      job.outcome = buildOutcome({
+        result: job.result ?? '',
+        deliveryMeta: job.delivery_metadata,
+        executionStatus: job.status === 'done' ? 'completed' : 'failed',
+        stopReason: job.stopReason,
+        deliveryMissing: job.delivery_missing,
+      });
+      job.phase = job.status === 'done' ? JOB_PHASES.COMPLETED : job.status === 'cancelled' ? JOB_PHASES.CANCELLED : JOB_PHASES.FAILED;
+      // Read-only after-snapshot of the workspace: bounded, redacted patch.
+      const baseline = await job.baselinePromise;
+      job.workspaceDiff = baseline.kind === 'git'
+        ? await captureWorkspaceDiff({ cwd: workspace, baseline }).catch(() => ({ kind: 'no-git', reason: NOT_A_GIT_REPOSITORY, error: 'workspace diff failed' }))
+        : baseline;
+      publishStatus();
+      for (const w of job.waiters.splice(0)) w();
+    });
+
+  publishStatus();
+  return job;
+}
+
+export async function waitJob(id, timeoutMs) {
+  const job = jobs.get(id);
+  if (!job) throw new Error(`no such job: ${id}`);
+  if (job.status !== 'running') return job;
+  await Promise.race([
+    new Promise((res) => job.waiters.push(res)),
+    timeoutMs ? new Promise((res) => setTimeout(res, timeoutMs)) : new Promise(() => {}),
+  ]);
+  return job;
+}
+
+export async function cancelJob(id) {
+  const job = jobs.get(id);
+  if (!job) throw new Error(`no such job: ${id}`);
+  if (job.status !== 'running') return job;
+  job.status = 'cancelled';
+  job.phase = JOB_PHASES.CANCELLED;
+  job.error = 'cancelled by request';
+  try { await job.harness.close(); } catch {}
+  publishStatus();
+  return job;
+}

package/src/mcp-runtime.mjs

@@ -0,0 +1,257 @@
+// MCP-side workflow runtime wiring: builds the shared workflow runtime with
+// the real Hub / Standalone attempt adapters and the git-worktree workspace
+// adapter. This is the only place that knows which transport executes an
+// attempt; the MCP server (src/server.mjs) only does schema, validation,
+// policy gating and formatting.
+//
+// Behaviour decisions (escalation, review, candidate, queue, cancellation)
+// live entirely in workflow-runtime.mjs; the adapters here just execute.
+
+import { createWorkflowRuntime } from './workflow-runtime.mjs';
+import { normalizeGlobalConfig } from './policy.mjs';
+import { buildDirectSelectionTrace, enrichSelectionTrace } from './model-routing.mjs';
+import {
+  createIsolatedWorkspace,
+  cleanupIsolatedWorkspace,
+  inspectRepository,
+  captureCandidate as captureIsolationCandidate,
+} from './workspace-isolation.mjs';
+import { startJob, waitJob, jobView, cancelJob } from './jobs.mjs';
+import { hub } from './hub-client.mjs';
+
+const SESSION_CONFIG_KEYS = [
+  'default_tier', 'default_effort', 'mode', 'default_timeout_seconds',
+  'tier_policy', 'escalate_on_failure', 'collaboration_mode', 'main_agent_mode',
+  'flash_state', 'pro_state', 'pro_reviews_flash',
+];
+
+/**
+ * Merge only defined session overrides onto the live global config before the
+ * workflow snapshots its policy. This keeps dsh_worker_config authoritative
+ * for escalation/review decisions instead of applying it only to the MCP gate.
+ */
+export function buildEffectiveRuntimeConfig(globalRaw = {}, session = {}) {
+  const patch = {};
+  for (const key of SESSION_CONFIG_KEYS) {
+    if (session?.[key] !== undefined) patch[key] = session[key];
+  }
+  if (session?.enabled === false) patch.subagents_enabled = false;
+  return normalizeGlobalConfig({ ...globalRaw, ...patch });
+}
+
+/**
+ * Translate a role/workflow attempt into the legacy model-class slot needed by
+ * Standalone and DeepSeek Official Hub routing. A user-requested strong worker
+ * starts on Pro; every escalated worker attempt also uses the strong slot.
+ */
+export function resolveAttemptTier({ role = 'worker', attempt = 0, modelClassHint } = {}) {
+  if (role === 'reviewer') return 'pro';
+  if (Number.isInteger(attempt) && attempt > 0) return 'pro';
+  if (modelClassHint === 'pro') return 'pro';
+  return 'flash';
+}
+
+/** Map a Hub/Standalone job view into the AttemptResult the runtime expects. */
+export function attemptFromView(view, spec) {
+  const role = view?.role ?? spec.role ?? 'worker';
+  const logicalAttempt = spec.attempt ?? 0;
+  const source = view?.selection_source ?? null;
+  const transportTrace = view?.selection_trace ?? buildDirectSelectionTrace({
+    role,
+    logicalAttempt,
+    modelClassHint: spec.model_class_hint ?? null,
+    strategy: source ?? 'transport-selection',
+    candidateSet: logicalAttempt > 0 ? 'escalation' : 'primary',
+    provider: view?.provider ?? null,
+    model: view?.model ?? null,
+    source: source ?? 'transport-selection',
+    escalationReason: spec.escalation_reason ?? null,
+  });
+  const selectionTrace = enrichSelectionTrace(transportTrace, {
+    role,
+    logicalAttempt,
+    modelClassHint: spec.model_class_hint ?? null,
+    escalationReason: spec.escalation_reason ?? null,
+  });
+  return {
+    id: view?.id ?? spec.id,
+    role,
+    // `view.attempt` may be an adapter routing-attempt (see below); the
+    // workflow's logical attempt number is always the spec value.
+    attempt: logicalAttempt,
+    provider: view?.provider ?? null,
+    model: view?.model ?? null,
+    selection_source: source,
+    selection_trace: selectionTrace,
+    status: view?.status ?? 'failed',
+    result: view?.result ?? null,
+    stopReason: view?.stopReason ?? null,
+    outcome: view?.outcome ?? null,
+    usage: view?.tokens ?? null,
+    error: view?.error ?? null,
+    error_code: view?.error_code ?? view?.code ?? null,
+  };
+}
+
+function timedOutAttempt(view, spec, timeoutMs) {
+  return {
+    ...attemptFromView(view, spec),
+    status: 'failed',
+    stopReason: 'timeout',
+    error: `attempt timed out after ${Math.ceil(timeoutMs / 1000)}s and was cancelled before any retry`,
+    timed_out: true,
+  };
+}
+
+/**
+ * Build the workflow runtime used by the MCP server.
+ *
+ * deps:
+ *   getSessionConfig()     -> session-level config (effort, timeout, mode...)
+ *   resolveMode()          -> 'hub' | 'standalone'
+ *   presetForTier(tier)    -> hub agent preset id for a tier slot (optional)
+ *   readGlobalConfig()     -> raw global config reader
+ *   buildReviewTask(task, view) -> reviewer prompt builder
+ *   attemptTimeoutMs()     -> default attempt execution timeout (optional)
+ */
+export function buildMcpWorkflowRuntime(deps) {
+  const { getSessionConfig, resolveMode, presetForTier, readGlobalConfig, buildReviewTask } = deps;
+  const getConfig = () => buildEffectiveRuntimeConfig(readGlobalConfig(), getSessionConfig?.() ?? {});
+  const getRuntimeControls = () => ({
+    max_parallel: getConfig().execution?.max_parallel ?? 3,
+  });
+
+  const executeAttempt = async (spec) => {
+    const session = getSessionConfig?.() ?? {};
+    const effort = spec.effort ?? session.default_effort ?? 'max';
+    const timeoutMs = (deps.attemptTimeoutMs?.() ?? (session.default_timeout_seconds ?? 1800) * 1000);
+    const tier = resolveAttemptTier({ role: spec.role, attempt: spec.attempt, modelClassHint: spec.model_class_hint });
+    const delivery = spec.role === 'reviewer' || spec.delivery === 'review' ? 'review' : 'coding';
+    const source = spec.source ?? 'api';
+    const preset = presetForTier?.(tier);
+
+    if ((await resolveMode()) === 'hub') {
+      // Hub follow-dsh currently uses `attempt` to choose primary vs escalation
+      // model policy. For an explicit worker+pro hint, route selection through
+      // the strong pool while preserving the workflow's logical attempt number
+      // in the normalized AttemptResult.
+      const routingAttempt = spec.role === 'worker' && spec.attempt === 0 && spec.model_class_hint === 'pro'
+        ? 1
+        : spec.attempt;
+      const spawned = await hub.spawn({
+        task: spec.task,
+        tier,
+        role: spec.role,
+        attempt: routingAttempt,
+        effort,
+        cwd: spec.cwd,
+        source,
+        preset,
+        delivery,
+      });
+      spec.onAttemptStarted?.(spawned.id);
+
+      const deadline = Date.now() + timeoutMs;
+      let resolved = spawned;
+      while (resolved?.status === 'running') {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+          let cancelled = resolved;
+          try { cancelled = await hub.cancel(spawned.id); } catch {}
+          return timedOutAttempt(cancelled, spec, timeoutMs);
+        }
+        const waitSeconds = Math.max(1, Math.min(600, Math.ceil(remainingMs / 1000)));
+        resolved = await hub.get(spawned.id, waitSeconds);
+      }
+      return attemptFromView(resolved, spec);
+    }
+
+    const job = startJob({
+      task: spec.task,
+      tier,
+      role: spec.role,
+      attempt: spec.attempt,
+      effort,
+      cwd: spec.cwd,
+      timeoutMs,
+      source,
+      delivery,
+      modelClassHint: spec.model_class_hint ?? null,
+      escalationReason: spec.escalation_reason ?? null,
+    });
+    spec.onAttemptStarted?.(job.id);
+    await waitJob(job.id, timeoutMs);
+    if (job.status === 'running') {
+      await cancelJob(job.id).catch(() => {});
+      return timedOutAttempt(jobView(job, { withResult: true }), spec, timeoutMs);
+    }
+    return attemptFromView(jobView(job, { withResult: true }), spec);
+  };
+
+  const cancelAttempt = async (id) => {
+    if (String(id ?? '').startsWith('hub-')) {
+      try { await hub.cancel(id); } catch {}
+      return;
+    }
+    try { await cancelJob(id); } catch {}
+  };
+
+  const allocateWorkspace = async (job) => {
+    const config = getConfig();
+    const isolation = config.execution?.isolation ?? 'worktree';
+    // Reviewer role / explicit review and shared mode never draft a candidate;
+    // they run in the requested workspace.
+    if (job.role === 'reviewer' || job.delivery === 'review' || isolation === 'shared') {
+      return { ok: true, execution_cwd: job.requested_cwd, isolation: 'shared', base_revision: null, primary_workspace_dirty: false, handle: null };
+    }
+    // Coding worker under worktree isolation: fail closed when the workspace
+    // is not a git repo — never silently fall back to sharing the working tree.
+    const repo = await inspectRepository({ cwd: job.requested_cwd });
+    if (!repo.ok) {
+      return { ok: false, reason: repo.reason ?? 'ISOLATION_UNAVAILABLE', error: `coding worker needs an isolated git worktree: ${repo.error ?? repo.reason}` };
+    }
+    const created = await createIsolatedWorkspace({ cwd: job.requested_cwd, jobId: job.id, baseRevision: repo.baseRevision });
+    if (!created.ok) {
+      return { ok: false, reason: created.reason ?? 'WORKTREE_CREATE_FAILED', error: `worktree create failed: ${created.error ?? ''}` };
+    }
+    return {
+      ok: true,
+      execution_cwd: created.worktreePath,
+      base_revision: created.baseRevision,
+      isolation: 'worktree',
+      primary_workspace_dirty: repo.dirty === true,
+      handle: { worktreePath: created.worktreePath, repoRoot: created.repoRoot },
+    };
+  };
+
+  const captureCandidate = async ({ cwd, baseRevision }) => captureIsolationCandidate({ worktreePath: cwd, baseRevision });
+
+  const releaseWorkspace = async (handle) => {
+    if (!handle) return { ok: true };
+    try {
+      const r = await cleanupIsolatedWorkspace({ worktreePath: handle.worktreePath, repoRoot: handle.repoRoot });
+      return { ok: r.ok, error: r.ok ? undefined : r.error };
+    } catch (err) {
+      return { ok: false, error: err?.message ?? String(err) };
+    }
+  };
+
+  const initialConfig = getConfig();
+  const runtime = createWorkflowRuntime(
+    {
+      executeAttempt,
+      cancelAttempt,
+      allocateWorkspace,
+      captureCandidate,
+      releaseWorkspace,
+      buildReviewTask,
+      getConfig,
+      getRuntimeControls,
+    },
+    {
+      maxParallel: initialConfig.execution?.max_parallel ?? 3,
+    },
+  );
+
+  return runtime;
+}