@ran-sh/dsh-crew 2.1.8 → 2.2.1

package/src/install/windows-supervisor-adapter.mjs

@@ -5,6 +5,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join, win32 } from 'node:path';
 import { homedir } from 'node:os';
 
+import { RELEASE_COHORT_FILENAME } from '../dsh-cohort.mjs';
 import {
   readMaintenanceSession,
   readSupervisorHeartbeat,
@@ -47,7 +48,7 @@ export function hashSupervisorHelper(file) {
   try { return createHash('sha256').update(readFileSync(file)).digest('hex'); } catch { return null; }
 }
 
-export function canonicalWindowsPowerShellPath({
+function canonicalWindowsPowerShellPath({
   environment = process.env,
   exists = existsSync,
 } = {}) {
@@ -344,7 +345,7 @@ function prepareWindowsSupervisorConvergence({ home, root, platform }) {
   let expectedDshVersion = text(manifest?.dependencies?.['@deepseek-ai/dsh'] ?? manifest?.peerDependencies?.['@deepseek-ai/dsh']);
   if (!EXACT_VERSION_RE.test(expectedDshVersion ?? '')) {
     try {
-      const cohort = JSON.parse(readFileSync(join(root, 'release-cohort.json'), 'utf8'));
+      const cohort = JSON.parse(readFileSync(join(root, RELEASE_COHORT_FILENAME), 'utf8'));
       expectedDshVersion = text(cohort?.dsh_version);
     } catch { expectedDshVersion = null; }
   }

package/src/install/windows-supervisor-lifecycle.mjs

@@ -10,8 +10,8 @@ import {
 import { dirname, join } from 'node:path';
 import { compareProcessToken, processStartToken } from '../process-identity.mjs';
 
-export const WINDOWS_SUPERVISOR_HANDOFF_SCHEMA = 1;
-export const WINDOWS_SUPERVISOR_HANDOFF_PHASES = Object.freeze([
+const WINDOWS_SUPERVISOR_HANDOFF_SCHEMA = 1;
+const WINDOWS_SUPERVISOR_HANDOFF_PHASES = Object.freeze([
   'planned',
   'backend-stopped',
   'old-watcher-stopped',

package/src/install/zcode.mjs

@@ -395,5 +395,3 @@ export function uninstallZCode({ home = homedir(), env = process.env } = {}) {
   }
   return { ok: true, actions };
 }
-
-export function zcodeOwnershipFile({ home = homedir() } = {}) { return OWNERSHIP_FILE({ home }); }

package/src/job-contracts.mjs

@@ -5,7 +5,7 @@
 // internal details remain available only through an explicit detail=full
 // request at the MCP boundary.
 
-export const JOB_CONTRACT_SCHEMA_VERSION = 1;
+const JOB_CONTRACT_SCHEMA_VERSION = 1;
 
 export const JOB_EVENT_TYPES = Object.freeze([
   'job.created',

package/src/job-identity.mjs

@@ -7,13 +7,20 @@
 // of the first message the agent receives — so they only agree if they are built
 // from the same string. This module is that string.
 //
-// The shape is `Crew_<YYYYMMDD>_<HHMMSS>_<purpose>`, matching the worktree naming
-// rule; `src/workspace-isolation.mjs` allocates worktrees in the same shape, and a
-// test asserts that every name produced here satisfies its ownership grammar, so
-// the two cannot drift apart silently.
+// The shape is `Crew_<YYYYMMDD>_<HHMMSS>_<purpose>`, matching the disposable
+// worktree naming rule; `src/workspace-isolation.mjs` allocates those in the same
+// shape, and a test asserts that every name produced here satisfies its ownership
+// grammar, so the two cannot drift apart silently. A job that runs in a
+// caller-supplied Crew worktree is still named after that directory.
+//
+// A job running in one of the stable per-role workspaces is the exception, and
+// the agreement above deliberately does not apply to it: `dsh-crew-worker` is
+// shared by every job that uses it, so naming jobs after their workspace would
+// give them all one title. There the workspace groups the sessions and this name
+// tells them apart.
 
-export const JOB_NAME_PREFIX = 'Crew_';
-export const JOB_PURPOSE_MAX = 32;
+const JOB_NAME_PREFIX = 'Crew_';
+const JOB_PURPOSE_MAX = 32;
 
 export const JOB_NAME_RE = /^Crew_\d{8}_\d{6}_[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*(?:-\d+)?$/;
 

package/src/jobs.mjs

@@ -14,8 +14,8 @@ import { createShardWriter } from './status-shard.mjs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join, resolve, basename } from 'node:path';
 import { homedir } from 'node:os';
-import { appendDeliveryInstructions, prependJobIdentity, parseDeliveryReport, formatDeliveryMetadata } from './delivery.mjs';
-import { jobDisplayName } from './job-identity.mjs';
+import { appendDeliveryInstructions, prependJobIdentity, parseDeliveryReport, formatDeliveryMetadata } from './delivery.mjs';
+import { jobDisplayName } from './job-identity.mjs';
 import { isCrewWorktreeName } from './workspace-isolation.mjs';
 import { captureWorkspaceBaseline, captureWorkspaceDiff, NOT_A_GIT_REPOSITORY } from './workspace-audit.mjs';
 import { buildOutcome, JOB_PHASES } from './workflow.mjs';
@@ -28,7 +28,6 @@ import { readGlobalConfig } from './install/install.mjs';
 const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 const CONFIG_DIR = join(homedir(), '.config', 'dsh-crew');
 const CREW_DSH_HOME = join(homedir(), '.config', 'dsh-crew', 'harness');
-const STATUS_FILE = join(CONFIG_DIR, 'status.json');
 const CORDIS = join(ROOT, 'worker.cordis.yml');
 
 // Read the operator's schedule once per dispatch. An unreadable config must not
@@ -38,7 +37,7 @@ function readModelSchedule() {
   try { return normalizeModelSchedule(readGlobalConfig().model_schedule); } catch { return normalizeModelSchedule(undefined); }
 }
 
-export const TIERS = {
+const TIERS = {
   flash: { model: 'deepseek-v4-flash', label: 'V4 Flash' },
   pro: { model: 'deepseek-v4-pro', label: 'V4 Pro' },
 };

package/src/mcp-runtime.mjs

@@ -11,7 +11,6 @@ import { createWorkflowRuntime } from './workflow-runtime.mjs';
 import { CONFIG_SCHEMA_VERSION, normalizeGlobalConfig } from './policy.mjs';
 import { buildDirectSelectionTrace, enrichSelectionTrace } from './model-routing.mjs';
 import {
-  createIsolatedWorkspace,
   cleanupIsolatedWorkspace,
   inspectRepository,
   captureCandidate as captureIsolationCandidate,
@@ -19,6 +18,7 @@ import {
 import { startJob, waitJob, jobView, cancelJob } from './jobs.mjs';
 import { hub } from './hub-client.mjs';
 import { crewHarnessSessionsDir } from './install/crew-paths.mjs';
+import { ensureCrewWorkspace, releaseCrewWorkspace } from './crew-workspaces.mjs';
 
 const SESSION_CONFIG_KEYS = [
   'default_tier', 'default_effort', 'mode', 'default_timeout_seconds',
@@ -301,25 +301,27 @@ export function buildMcpWorkflowRuntime(deps) {
     if (!repo.ok) {
       return { ok: false, reason: repo.reason ?? 'ISOLATION_UNAVAILABLE', error: `${job.role ?? 'worker'} needs an isolated git worktree: ${repo.error ?? repo.reason}` };
     }
-    // The worktree name carries what the job was for, so an operator reading the
-    // directory list can tell a worker tree from a reviewer tree without opening
-    // anything. Role is the honest answer; it is what the job actually is.
-    const created = await createIsolatedWorkspace({
+    // The job runs in this project's stable worker/reviewer workspace rather
+    // than a worktree of its own, so the sessions the Harness groups by cwd
+    // accumulate in two entries instead of one per job. The workspace is reset
+    // to the job's base revision on the way in, so the candidate diff is still
+    // this job's work alone, and it is held for the job's duration so two jobs
+    // cannot share it.
+    const workspace = await ensureCrewWorkspace({
       cwd: job.requested_cwd,
-      jobId: job.id,
-      purpose: job.role ?? 'job',
+      role: job.role ?? 'worker',
       baseRevision: job.workspace_branch ?? repo.baseRevision,
     });
-    if (!created.ok) {
-      return { ok: false, reason: created.reason ?? 'WORKTREE_CREATE_FAILED', error: `worktree create failed: ${created.error ?? ''}` };
+    if (!workspace.ok) {
+      return { ok: false, reason: workspace.reason ?? 'WORKTREE_CREATE_FAILED', error: `workspace unavailable: ${workspace.error ?? ''}` };
     }
     return {
       ok: true,
-      execution_cwd: created.worktreePath,
-      base_revision: created.baseRevision,
+      execution_cwd: workspace.worktreePath,
+      base_revision: workspace.baseRevision,
       isolation: 'worktree',
       primary_workspace_dirty: repo.dirty === true,
-      handle: { worktreePath: created.worktreePath, repoRoot: created.repoRoot },
+      handle: { worktreePath: workspace.worktreePath, repoRoot: workspace.repoRoot, stable: true, release: workspace.release },
     };
   };
 
@@ -327,6 +329,9 @@ export function buildMcpWorkflowRuntime(deps) {
 
   const releaseWorkspace = async (handle) => {
     if (!handle) return { ok: true };
+    // A stable workspace is not disposed of — it is the directory the next job
+    // and every session it produced belong to. Only the lock is dropped.
+    if (handle.stable === true) return { ok: releaseCrewWorkspace(handle) };
     try {
       const r = await cleanupIsolatedWorkspace({ worktreePath: handle.worktreePath, repoRoot: handle.repoRoot });
       return { ok: r.ok, error: r.ok ? undefined : r.error };

package/src/model-routing.mjs

@@ -7,7 +7,7 @@
 import { rankAdaptiveCandidates } from './adaptive-routing.mjs';
 import { scheduleAdmission } from './model-schedule.mjs';
 
-export const DEFAULT_TIER_MODEL_PREFERENCES = Object.freeze({
+const DEFAULT_TIER_MODEL_PREFERENCES = Object.freeze({
   flash: 'deepseek-v4-flash',
   pro: 'deepseek-v4-pro',
 });
@@ -20,9 +20,8 @@ export const DEFAULT_ROLE_MODEL_PREFERENCES = Object.freeze({
   reviewer: 'deepseek-v4-pro',
 });
 
-export const MODEL_FALLBACKS = ['harness-default'];
 export const NO_WORKER_MODEL_AVAILABLE = 'NO_WORKER_MODEL_AVAILABLE';
-export const MODEL_SELECTION_TRACE_VERSION = 1;
+const MODEL_SELECTION_TRACE_VERSION = 1;
 export const MODEL_SELECTION_REASON_CODES = Object.freeze({
   PROVIDER_UNAVAILABLE: 'PROVIDER_UNAVAILABLE',
   PREFERRED_MODEL_UNAVAILABLE: 'PREFERRED_MODEL_UNAVAILABLE',
@@ -61,7 +60,7 @@ const BLOCKED_MODEL_CODES = Object.freeze({
   [MODEL_SELECTION_REASON_CODES.PEAK_RESTRICTED]: 'MODEL_BLOCKED_PEAK',
 });
 
-export function normalizeModelRef(raw) {
+function normalizeModelRef(raw) {
   if (!raw || typeof raw !== 'object') return null;
   const provider = typeof raw.provider === 'string' ? raw.provider.trim() : '';
   const model = typeof raw.model === 'string' ? raw.model.trim() : '';

package/src/model-schedule.mjs

@@ -27,7 +27,6 @@ export const DEFAULT_PEAK_WINDOWS = Object.freeze([
 
 export const DEFAULT_TIMEZONE_OFFSET_MINUTES = 8 * 60;
 export const DEFAULT_PEAK_WEEKDAYS = Object.freeze([1, 2, 3, 4, 5]);
-export const MINUTES_PER_DAY = 24 * 60;
 // A fixed offset is bounded by the real-world range of UTC offsets; anything
 // wider is a typo, not a timezone.
 const MAX_OFFSET_MINUTES = 14 * 60;

package/src/policy-legacy.mjs

@@ -21,8 +21,8 @@ import { normalizeModelPriority } from './model-routing.mjs';
 
 export const TIER_STATES = ['disabled', 'manual', 'auto'];
 export const COLLABORATION_MODES = ['flash-only', 'pro-only', 'balanced', 'review-pipeline', 'custom'];
-export const MAIN_AGENT_MODES = ['direct-allowed', 'coordinator-first', 'dispatcher-only'];
-export const ROLE_IDS = [
+const MAIN_AGENT_MODES = ['direct-allowed', 'coordinator-first', 'dispatcher-only'];
+const ROLE_IDS = [
   'implementation',
   'simple_fix',
   'tests',
@@ -52,7 +52,7 @@ export const POLICY_ERROR_CODES = {
   ROLE_TIER_CONFLICT: 'ROLE_TIER_CONFLICT',
 };
 
-export const POLICY_ERROR_MESSAGES = {
+const POLICY_ERROR_MESSAGES = {
   [POLICY_ERROR_CODES.SUBAGENTS_DISABLED]:
     'DSH Crew worker dispatch is disabled.',
   [POLICY_ERROR_CODES.TIER_DISABLED]:
@@ -89,18 +89,16 @@ export const POLICY_ERROR_MESSAGES = {
 // Everything new here reads a canonical config shape produced by
 // migrateLegacyConfig; the legacy collab/tier functions stay for compatibility.
 
-export const DISPATCH_ROLES = ['worker', 'reviewer'];
-export const ROLE_STATES = TIER_STATES; // disabled | manual | auto
 export const ROLE_MODEL_STRATEGIES = ['economy', 'balanced', 'quality', 'strong'];
-export const DEFAULT_WORKER_STRATEGY = 'balanced';
-export const DEFAULT_REVIEWER_STRATEGY = 'strong';
+const DEFAULT_WORKER_STRATEGY = 'balanced';
+const DEFAULT_REVIEWER_STRATEGY = 'strong';
 export const DEFAULT_MAX_PARALLEL = 3;
 
-export function normalizeRoleState(raw) {
+function normalizeRoleState(raw) {
   return normalizeState(raw);
 }
 
-export function normalizeIsolation(raw) {
+function normalizeIsolation(raw) {
   return raw === 'worktree' || raw === 'shared' ? raw : 'worktree';
 }
 
@@ -117,7 +115,7 @@ function normalizeMaxParallel(raw) {
  *   escalation_priority_configured, fallback, escalation: { enabled, max_attempts } }.
  * Pure; unknown fields drop, empty priority falls back to the role default.
  */
-export function normalizeModelPolicy(raw = {}) {
+function normalizeModelPolicy(raw = {}) {
   return {
     role: raw.role === 'reviewer' ? 'reviewer' : 'worker',
     strategy: ROLE_MODEL_STRATEGIES.includes(raw.strategy)
@@ -444,7 +442,7 @@ export function resolveHubWorkerProvider({ worker_provider_mode, getCurrentSelec
 }
 
 /** Structured policy error; `code` is machine-readable, `message` user-facing. */
-export function policyError(code, extra = {}) {
+function policyError(code, extra = {}) {
   const base = POLICY_ERROR_MESSAGES[code] ?? code;
   return Object.assign(new Error(base.replace('{tier}', extra.tier ?? 'pro')), { policyCode: code });
 }
@@ -677,7 +675,7 @@ export function shouldRunProReview(config, session = {}) {
 }
 
 /** Roles for a tier (host guidance for who does what, not a hard classifier). */
-export function getTierRoles(config, tier) {
+function getTierRoles(config, tier) {
   const roles = tier === 'flash' ? config.flash_roles : config.pro_roles;
   return normalizeRoles(roles, tier === 'flash' ? DEFAULT_FLASH_ROLES : DEFAULT_PRO_ROLES);
 }

package/src/provider-inventory.mjs

@@ -9,7 +9,7 @@ import { classifyCredentialReference } from './credential-reference.mjs';
 const LIFECYCLE_ORIGINS = new Set(['builtin', 'profile-managed', 'dynamic', 'unknown']);
 const OWNERSHIPS = new Set(['harness', 'crew-managed-profile', 'user-managed-profile', 'dynamic-user', 'unknown']);
 const MUTABLE_AUTHORITY_KINDS = new Set(['crew-profile', 'harness-settings']);
-export const IMMUTABLE_HARNESS_PROVIDER_IDS = Object.freeze(['deepseek-official']);
+const IMMUTABLE_HARNESS_PROVIDER_IDS = Object.freeze(['deepseek-official']);
 
 function text(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;

package/src/provider-layer-migration.mjs

@@ -120,8 +120,6 @@ export function hasProviderLayerMigration(plan) {
   return Array.isArray(plan?.providers) && plan.providers.length > 0;
 }
 
-const MIGRATION_STATES = Object.freeze(['PLANNED', 'APPLIED', 'RESTART_PENDING', 'VERIFYING', 'VERIFIED', 'FAILED']);
-
 function migrationCode(error, fallback = 'PROVIDER_MIGRATION_FAILED') {
   const code = text(error?.code);
   return code && /^[A-Z][A-Z0-9_]{1,63}$/u.test(code) ? code : fallback;

package/src/readiness-matrix.mjs

@@ -5,7 +5,7 @@
 // (Hub handshake / catalog read) are intentionally separate from execution
 // verification (real worker, reviewer, cancellation, timeout, etc.).
 
-export const READINESS_STATUSES = Object.freeze(['PASS', 'FAIL', 'BLOCKED', 'SKIP', 'NOT_RUN']);
+const READINESS_STATUSES = Object.freeze(['PASS', 'FAIL', 'BLOCKED', 'SKIP', 'NOT_RUN']);
 
 export const READINESS_REASON_CODES = Object.freeze({
   LIVE_CHECK_PASSED: 'LIVE_CHECK_PASSED',

package/src/release-in-use.mjs

@@ -22,7 +22,7 @@ import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-export const IN_USE_DIRNAME = 'in-use';
+const IN_USE_DIRNAME = 'in-use';
 
 // A claim file is `<pid>.json` or `<pid>-<nonce>.json`. The PID alone is not
 // enough to identify a claim: two mounts inside one process would publish to the

package/src/role-profiles.mjs

@@ -6,7 +6,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 
-export const ROLE_PROFILE_SCHEMA_VERSION = 1;
+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,
@@ -45,7 +45,7 @@ function normalizeProfile(id, raw) {
   };
 }
 
-export function roleProfilesFile({ home = homedir() } = {}) {
+function roleProfilesFile({ home = homedir() } = {}) {
   return join(home, '.config', 'dsh-crew', 'profiles.json');
 }
 

package/src/runtime-controls.mjs

@@ -22,7 +22,7 @@ const R = ACTIVATION_BOUNDARY.RESTART_REQUIRED;
  * running MCP process. `session: null` means the setting is not a session
  * override surface.
  */
-export const RUNTIME_SETTING_ACTIVATION = Object.freeze({
+const RUNTIME_SETTING_ACTIVATION = Object.freeze({
   max_parallel: Object.freeze({ global: L, session: null, note: 'Admission limit refreshes before new workflow starts and when slots release; lowering never cancels active work.' }),
 
   subagents_enabled: Object.freeze({ global: N, session: N }),

package/src/runtime-identity.mjs

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

package/src/status-shard.mjs

@@ -9,7 +9,7 @@ import { homedir } from 'node:os';
 
 const CONFIG_DIR = join(homedir(), '.config', 'dsh-crew');
 const SHARD_DIR = join(CONFIG_DIR, 'status.d');
-export const SHARD_FRESH_MS = 30 * 60 * 1000;
+const SHARD_FRESH_MS = 30 * 60 * 1000;
 
 export function createShardWriter(kind) {
   const writer = `${kind}-${process.pid}`;

package/src/supervisor/restart-request.mjs

@@ -18,18 +18,18 @@ import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 
-export const RESTART_REQUEST_SCHEMA = 1;
-export const RESTART_REQUEST_TTL_MS = 60_000;
+const RESTART_REQUEST_SCHEMA = 1;
+const RESTART_REQUEST_TTL_MS = 60_000;
 
 export function supervisorStateRoot(appRoot) {
   return join(appRoot, 'supervisor');
 }
 
-export function restartRequestsDir(appRoot) {
+function restartRequestsDir(appRoot) {
   return join(supervisorStateRoot(appRoot), 'restart-requests');
 }
 
-export function restartResultsDir(appRoot) {
+function restartResultsDir(appRoot) {
   return join(supervisorStateRoot(appRoot), 'restart-results');
 }
 

package/src/workflow-runtime.mjs

@@ -31,7 +31,6 @@ export const WORKFLOW_ERROR_CODES = {
   REVIEWER_MUTATED_CANDIDATE: 'REVIEWER_MUTATED_CANDIDATE',
 };
 
-const TERMINAL = new Set([JOB_PHASES.COMPLETED, JOB_PHASES.FAILED, JOB_PHASES.CANCELLED, JOB_PHASES.INTERRUPTED]);
 
 function lines(value) {
   if (typeof value !== 'string' || value.trim() === '') return [];
@@ -817,4 +816,4 @@ export function createWorkflowRuntime(adapters, {
   return { start, wait, get, list, cancel, runtimeState, setMaxParallel, refreshRuntimeControls };
 }
 
-export { JOB_PHASES, TERMINAL };
+export { JOB_PHASES };

package/src/workspace-context.mjs

@@ -6,7 +6,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync
 import { homedir } from 'node:os';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 
-export const WORKSPACE_CONTEXT_SCHEMA_VERSION = 1;
+const WORKSPACE_CONTEXT_SCHEMA_VERSION = 1;
 const ID = /^[a-z0-9][a-z0-9._-]{0,63}$/;
 
 export function isSafeBranchName(value) {
@@ -51,7 +51,7 @@ function normalizeContext(id, raw) {
   };
 }
 
-export function workspaceContextsFile({ home = homedir() } = {}) {
+function workspaceContextsFile({ home = homedir() } = {}) {
   return join(home, '.config', 'dsh-crew', 'workspaces.json');
 }
 

package/src/workspace-isolation.mjs

@@ -28,9 +28,9 @@ export const GIT_ERROR = 'GIT_ERROR';
 /** A valid repository whose HEAD does not resolve because nothing is committed. */
 export const REPOSITORY_HAS_NO_COMMITS = 'REPOSITORY_HAS_NO_COMMITS';
 export const WORKTREE_LOCKED = 'WORKTREE_LOCKED';
-export const WORKTREE_RESERVE_FAILED = 'WORKTREE_RESERVE_FAILED';
+const WORKTREE_RESERVE_FAILED = 'WORKTREE_RESERVE_FAILED';
 export const CANDIDATE_CAPTURE_FAILED = 'CANDIDATE_CAPTURE_FAILED';
-export const MAX_PARALLEL_CAP = 16;
+const MAX_PARALLEL_CAP = 16;
 export const DEFAULT_MAX_PARALLEL = 3;
 // Worktree names read `Crew_YYYYMMDD_HHMMSS_<purpose>` so an operator can tell
 // from the directory alone when a job ran and what it was for. Worktrees from
@@ -642,8 +642,75 @@ async function ownershipDrift(run, worktreePath, expect) {
  * the registration is gone and no directory remains — success is never claimed
  * while a worktree stays registered or on disk.
  */
-export const WORKTREE_CLEANUP_RETRIES = 3;
-export const WORKTREE_CLEANUP_BACKOFF_MS = 150;
+const WORKTREE_CLEANUP_RETRIES = 3;
+const WORKTREE_CLEANUP_BACKOFF_MS = 150;
+
+/**
+ * Is `worktreePath` a worktree Crew created, for this repository?
+ *
+ * The same identity check the automatic prune uses, exposed for the stable
+ * per-role workspaces: they are created once and then adopted by every later
+ * job, and "adopt" has to mean the same thing it means to the pruner — shape,
+ * name, path, repository and incarnation all matching a record Crew wrote.
+ * Anything less would let a directory that merely has the right name be reused
+ * as if Crew had made it.
+ */
+export async function crewOwnsWorktree({ worktreePath, repoRoot, git } = {}) {
+  const run = git ?? defaultRunner;
+  const repo = await commonDirOf(run, repoRoot);
+  if (!repo) return false;
+  const incarnation = await incarnationOf(run, worktreePath);
+  return Boolean(readOwnership({ worktreePath, repo, incarnation }));
+}
+
+/**
+ * Create a worktree of `repoRoot` at an exact path, and record ownership.
+ *
+ * `createIsolatedWorkspace` reserves a name it invents; the stable per-role
+ * workspaces already have their path, so this is the same creation without the
+ * reservation step. Ownership is recorded only after git succeeded, so a failed
+ * creation never leaves a claim on a tree that does not exist.
+ */
+export async function createWorktreeAt({ dir, repoRoot, revision, purpose, at, git } = {}) {
+  const run = git ?? defaultRunner;
+  const res = await runGit(run, ['worktree', 'add', '--detach', dir, revision], { cwd: repoRoot });
+  if (!res.ok) {
+    const released = await cleanupIsolatedWorkspace({ worktreePath: dir, repoRoot, git: run, reservation: true });
+    return {
+      ok: false,
+      reason: res.reason,
+      error: res.error,
+      ...(released.ok ? {} : { cleanupBlocked: true, cleanupError: released.error }),
+    };
+  }
+  const headRes = await runGit(run, ['rev-parse', 'HEAD'], { cwd: dir });
+  const created = headRes.ok ? headRes.stdout.trim() : '';
+  const commonDir = await commonDirOf(run, repoRoot);
+  const incarnation = commonDir ? await claimIncarnation(run, dir) : null;
+  const owned = Boolean(commonDir && incarnation && created)
+    && recordOwnership({ worktreePath: dir, repo: commonDir, incarnation, head: created, purpose, at });
+  return { ok: true, worktreePath: dir, repoRoot, owned };
+}
+
+/**
+ * Return a stable workspace to a known revision before a job starts.
+ *
+ * The workspace outlives the job, so without this a job would inherit whatever
+ * the previous one left — and the candidate diff, which is taken against a base
+ * revision, would then contain someone else's work. `reset --hard` discards
+ * tracked modifications; `clean -fd` removes untracked files but deliberately
+ * not ignored ones, so a workspace's `node_modules` survives. A reset that fails
+ * is reported rather than ignored: starting a job on an unknown tree is what the
+ * reset exists to prevent.
+ */
+export async function resetWorktreeTo({ worktreePath, revision, git } = {}) {
+  const run = git ?? defaultRunner;
+  const reset = await runGit(run, ['reset', '--hard', revision], { cwd: worktreePath });
+  if (!reset.ok) return { ok: false, reason: reset.reason, error: reset.error };
+  const clean = await runGit(run, ['clean', '-fd'], { cwd: worktreePath });
+  if (!clean.ok) return { ok: false, reason: clean.reason, error: clean.error };
+  return { ok: true };
+}
 
 export async function cleanupIsolatedWorkspace({
   worktreePath,