@ran-sh/dsh-crew 2.1.8 → 2.2.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-crew",
-  "version": "2.1.8",
+  "version": "2.2.0",
   "description": "Dispatch subtasks to DeepSeek Harness (DSH) agents as native subagents with live progress",
   "author": {
     "name": "ZSeven-W"

package/docs/job-contracts.md

@@ -8,7 +8,7 @@ back to the caller.
 
 ```text
 caller objective
-  -> Worker in isolated workspace
+  -> Worker in the project's stable worker workspace (or a caller-named one)
   -> structured outcome + candidate reference
   -> optional Reviewer inspects the workspace directly
   -> compact Result Contract + canonical job events
@@ -22,6 +22,10 @@ changes/tests/risks, changed-file names, base revision, and candidate
 fingerprint. It opens the relevant files and runs `git diff` in the isolated
 workspace when deeper inspection is needed.
 
+The workspace a job ran in is grouped by directory, not created per job: a
+reviewer reviewing in place runs in the worker's workspace, and only an explicit
+reviewer gets `dsh-crew-review`. See the isolation note above.
+
 The capsule also carries a pointer to the reviewed attempt's persisted execution
 record — the Hub session id plus the Crew harness session store — because a
 transient change leaves nothing in the workspace to inspect once it has been
@@ -95,6 +99,15 @@ Per-job precedence is request `constraints` > Profile > session defaults.
 `auto`, `existing`, or `none`. Workspace preflight reports `READY`, `CONFLICT`,
 `READ_ONLY`, or `UNAVAILABLE` before dispatch.
 
+With the default isolation a job runs in its project's stable workspace —
+`dsh-crew-worker`, or `dsh-crew-review` for an explicit reviewer — rather than a
+tree of its own, which is what keeps the Harness session panel at two entries per
+project. The workspace is reset to the job's base revision before it runs, so the
+candidate is still that job's work alone, and it is held for the job's duration: a
+second job finds it held and is refused with `WORKSPACE_BUSY` instead of sharing a
+tree with the first. `none` (shared) keeps the caller's directory and takes no
+lock.
+
 `constraints.allow_no_changes: true` is for tasks explicitly expected to leave
 no net workspace changes, including read-only search/inspection and bounded
 temporary smoke work. It does not blindly convert a partial Delivery Report

package/docs/readiness-matrix.md

@@ -39,13 +39,32 @@ rows remain `NOT_RUN` until a trusted higher layer supplies explicit evidence.
 - `provider_health`
 - `reviewer_health`
 - `model_execution`
+- `worker_primary_callable`
+- `worker_escalation_callable`
+- `reviewer_primary_callable`
+- `provider_lifecycle_consistent`
 - `deepseek_flash`
 - `deepseek_pro`
-- `opencode_go_mimo_qwen`
 - `reviewer_pipeline`
 - `cancellation_timeout_escalation`
 - `standalone_official`
 
+This list is the one the code builds; it had drifted, listing a row that was
+removed and omitting four that exist.
+
+Coverage of a provider is not a row per provider. `deepseek_flash` and
+`deepseek_pro` are the exception: they name DeepSeek Official because that
+provider has its own slots, and a machine running its workers elsewhere has no
+such execution to show — the row says so rather than borrowing another
+provider's. Everything else that answers "can this machine's configured route
+actually run" — `provider_health`, `reviewer_health`, `model_execution`,
+`worker_primary_callable`, `reviewer_primary_callable`, `reviewer_pipeline` — is
+filtered to whatever route is currently selected, so an operator on other
+providers is covered by those and loses nothing by the two DeepSeek rows
+reading `NOT_RUN`. A static row per provider was tried and replaced by these
+dynamic signals; `opencode_go_mimo_qwen` was that attempt's last trace in this
+document.
+
 `provider_health` and `reviewer_health` describe only the currently resolved
 Worker and Reviewer routes. A fresh negative observation overrides historical
 success; unrelated providers and stale observations do not. Historical jobs

package/lib/client.js

@@ -570,8 +570,8 @@ const copy = {
 		delete: "删除（不可恢复）",
 		scope: "范围",
 		all: "全部（含你自己的会话）",
-		crew: "仅 Crew 创建（推荐）",
-		worktree: "仅 Crew 工作树",
+		crew: "仅 Crew 创建",
+		worktree: "仅 Crew 工作区（推荐）",
 		before: "指定时间之前",
 		time: "创建时间早于",
 		timeHint: "按本机时区选择，严格按创建时间筛选；包含新会话的工作区会保留。",
@@ -612,8 +612,8 @@ const copy = {
 		delete: "Delete (permanent)",
 		scope: "Scope",
 		all: "Everything (includes your own sessions)",
-		crew: "Crew-created only (recommended)",
-		worktree: "Crew worktrees only",
+		crew: "Crew-created only",
+		worktree: "Crew workspaces only (recommended)",
 		before: "Before a date",
 		time: "Created before",
 		timeHint: "Local timezone; strict creation-time cutoff. Workspaces with newer sessions are kept.",
@@ -651,7 +651,8 @@ function HistoryPanel({ locale }) {
 	const t = copy[locale === "zh" ? "zh" : "en"];
 	const [open, setOpen] = (0, react.useState)(false);
 	const [operation, setOperation] = (0, react.useState)("archive");
-	const [scope, setScope] = (0, react.useState)("crew");
+	const [scope, setScope] = (0, react.useState)("worktree");
+	const timeScoped = scope === "before" || scope === "worktree";
 	const [before, setBefore] = (0, react.useState)("");
 	const [preview, setPreview] = (0, react.useState)(null);
 	const [status, setStatus] = (0, react.useState)({ phase: "IDLE" });
@@ -816,7 +817,7 @@ function HistoryPanel({ locale }) {
 						})
 					] })]
 				}),
-				scope === "before" && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [
+				timeScoped && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("label", { children: [
 					t.time,
 					" ",
 					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
@@ -840,11 +841,11 @@ function HistoryPanel({ locale }) {
 				/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
 					type: "button",
 					style,
-					disabled: locked || !connected || scope === "before" && !Number.isFinite(new Date(before).getTime()),
+					disabled: locked || !connected || timeScoped && before !== "" && !Number.isFinite(new Date(before).getTime()) || scope === "before" && before === "",
 					onClick: () => void act("preview", {
 						operation,
 						scope,
-						...scope === "before" ? { before: new Date(before).toISOString() } : {}
+						...timeScoped && before !== "" ? { before: new Date(before).toISOString() } : {}
 					}),
 					children: t.preview
 				}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ran-sh/dsh-crew",
-  "version": "2.1.8",
+  "version": "2.2.0",
   "type": "module",
   "main": "./src/hub/entry.mjs",
   "bin": {

package/skills/dsh-crew/SKILL.md

@@ -90,20 +90,23 @@ review asks for changes, that is a task result to act on — not approval.
   auditable evidence, and a reply with neither a change nor a verified check is
   incomplete. That is the gate working, not the worker failing. A task that
   changes nothing *on purpose* can pass — see the next entry.
-- **A job is named `Crew_<date>_<time>_<purpose>`.** The worktree directory, the
-  session the Harness lists in its workspace panel, and the name in a status
-  payload all use that one string, so a conversation can be matched to a
-  directory by eye. The purpose is the role: `worker` or `reviewer`.
+- **A project has two workspaces, and a job is named `Crew_<date>_<time>_<purpose>`.**
+  Worker jobs and the review that follows one run in `dsh-crew-worker`; an
+  explicit reviewer runs in `dsh-crew-review`. The Harness groups sessions by the
+  directory a job ran in, so those two are what an operator sees in the panel,
+  however many jobs have run. The job's own name still distinguishes it inside
+  the group.
 - **A verified zero-change task needs `constraints.allow_no_changes: true`.**
   For a deliberately temporary job — create, verify, clean up, end with an empty
   diff — that flag plus the reported checks is what certifies it. It requires a
   clean, readable baseline, at least one `PASS` and no `FAIL`, and it relaxes
   nothing else: no evidence, a failed check, a dirty baseline or an actual change
   each still refuse.
-- **Isolated workspaces need git.** The default `worktree` isolation fails with
+- **Isolated workspaces need git.** The default isolation fails with
   `NOT_GIT_REPOSITORY` for a non-git workspace rather than silently sharing the
-  tree. Use `shared` deliberately if that is what you want; `allow_no_changes`
-  works in either.
+  tree; a directory already sitting at the workspace path that Crew did not
+  create fails with `WORKSPACE_CONFLICT` instead of being deleted. Use `shared`
+  deliberately if that is what you want; `allow_no_changes` works in either.
 - **A repository with no commits cannot be isolated.** `git init` with nothing
   committed reports `REPOSITORY_HAS_NO_COMMITS` — there is no revision to start
   from. Commit once, or run that job with `shared`.
@@ -140,11 +143,13 @@ unrestricted. Defaults mirror DeepSeek's published peak hours.
 
 ## Work
 
-`isolation: worktree` is the default: a coding worker runs in a per-job git
-worktree and the primary tree is untouched. Non-git workspaces fail with
-`NOT_GIT_REPOSITORY` rather than silently sharing the tree; use `shared`
-explicitly if that is what you want. Concurrent jobs are capped by
-`max_parallel`.
+The default isolation gives a coding worker a git worktree of its own project,
+and the primary tree is untouched. That worktree is the project's stable worker
+or reviewer workspace, reset to the job's base revision before it runs, so the
+candidate diff is that job's work alone. One job at a time runs in each — a
+second finds the workspace held and is refused with `WORKSPACE_BUSY` rather than
+sharing it, because two jobs in one tree would each see the other's edits. So
+concurrency is bounded by workspaces even where `max_parallel` is higher.
 
 The reviewer gate is `required` by default: an unreviewed change fails. Review
 findings and failing tests are results to address, never a reason to bypass the
@@ -153,9 +158,13 @@ gate.
 ## History
 
 Session storage is shared between 3080 and 3210 — clearing one clears both.
-Cleanup is scoped by provenance, and the default scope is **Crew-created only**,
-so the operator's own conversations survive. `all` removes theirs too; use it
-deliberately. Archived batches are restorable from the panel.
+The default scope is **Crew's own workspaces**: sessions Crew recorded creating
+that ran in `dsh-crew-worker`, `dsh-crew-review`, or a per-job worktree an
+earlier release left behind. The operator's own conversations survive, and so
+does anything Crew ran in a directory that is not one of its workspaces.
+`all` removes theirs too; use it deliberately. The panel's date field narrows
+any scope to sessions created before it, and workspaces with newer sessions are
+kept. Archived batches are restorable from the panel.
 
 ## When Crew is unavailable
 

package/src/client/history-panel.tsx

@@ -5,7 +5,7 @@ const pending = (phase?: string) => !!phase && !['IDLE', 'DONE', 'FAILED', 'ROLL
 const copy = {
   zh: {
     title: '工作区与会话清理', intro: '仅影响 3210 的工作区记录与会话日志；不删除项目文件、附件或 3080 数据。',
-    operation: '操作', archive: '归档（可恢复）', delete: '删除（不可恢复）', scope: '范围', all: '全部（含你自己的会话）', crew: '仅 Crew 创建（推荐）', worktree: '仅 Crew 工作树', before: '指定时间之前',
+    operation: '操作', archive: '归档（可恢复）', delete: '删除（不可恢复）', scope: '范围', all: '全部（含你自己的会话）', crew: '仅 Crew 创建', worktree: '仅 Crew 工作区（推荐）', before: '指定时间之前',
     time: '创建时间早于', timeHint: '按本机时区选择，严格按创建时间筛选；包含新会话的工作区会保留。',
     preview: '预览清理范围', confirm: '确认执行', acknowledgement: '删除确认：请输入 DELETE', idle: '会短暂停止并重启 3210；请先结束或关闭所有正在使用的 3210 会话。',
     consent: '我已确认范围，并同意短暂重启 3210', restore: '恢复', archives: '已归档批次', empty: '暂无可恢复的归档',
@@ -17,7 +17,7 @@ const copy = {
   },
   en: {
     title: 'Workspace & session cleanup', intro: 'Only 3210 workspace records and session logs. Project files, attachments and 3080 data are untouched.',
-    operation: 'Action', archive: 'Archive (restorable)', delete: 'Delete (permanent)', scope: 'Scope', all: 'Everything (includes your own sessions)', crew: 'Crew-created only (recommended)', worktree: 'Crew worktrees only', before: 'Before a date',
+    operation: 'Action', archive: 'Archive (restorable)', delete: 'Delete (permanent)', scope: 'Scope', all: 'Everything (includes your own sessions)', crew: 'Crew-created only', worktree: 'Crew workspaces only (recommended)', before: 'Before a date',
     time: 'Created before', timeHint: 'Local timezone; strict creation-time cutoff. Workspaces with newer sessions are kept.',
     preview: 'Preview cleanup', confirm: 'Confirm operation', acknowledgement: 'Type DELETE to confirm deletion', idle: '3210 will briefly stop and restart. End or close all active 3210 conversations first.',
     consent: 'I reviewed the scope and agree to restart 3210', restore: 'Restore', archives: 'Archived batches', empty: 'No restorable archives',
@@ -33,7 +33,8 @@ export function HistoryPanel({ locale }: { locale: string }) {
   const t = copy[locale === 'zh' ? 'zh' : 'en'];
   const [open, setOpen] = useState(false);
   const [operation, setOperation] = useState('archive');
-  const [scope, setScope] = useState('crew');
+  const [scope, setScope] = useState('worktree');
+  const timeScoped = scope === 'before' || scope === 'worktree';
   const [before, setBefore] = useState('');
   const [preview, setPreview] = useState<any>(null);
   const [status, setStatus] = useState<any>({ phase: 'IDLE' });
@@ -83,9 +84,9 @@ export function HistoryPanel({ locale }: { locale: string }) {
         <label>{t.operation} <select style={style} value={operation} disabled={locked} onChange={e => { setOperation(e.target.value); invalidate(); }}><option value="archive">{t.archive}</option><option value="delete">{t.delete}</option></select></label>
         <label>{t.scope} <select style={style} value={scope} disabled={locked} onChange={e => { setScope(e.target.value); invalidate(); }}><option value="crew">{t.crew}</option><option value="worktree">{t.worktree}</option><option value="all">{t.all}</option><option value="before">{t.before}</option></select></label>
       </div>
-      {scope === 'before' && <label>{t.time} <input type="datetime-local" style={style} value={before} disabled={locked} onChange={e => { setBefore(e.target.value); invalidate(); }} /></label>}
+      {timeScoped && <label>{t.time} <input type="datetime-local" style={style} value={before} disabled={locked} onChange={e => { setBefore(e.target.value); invalidate(); }} /></label>}
       <div style={{ fontSize: 11.5, opacity: .7 }}>{t.timeHint}</div>
-      <button type="button" style={style} disabled={locked || !connected || (scope === 'before' && !Number.isFinite(new Date(before).getTime()))} onClick={() => void act('preview', { operation, scope, ...(scope === 'before' ? { before: new Date(before).toISOString() } : {}) })}>{t.preview}</button>
+      <button type="button" style={style} disabled={locked || !connected || (timeScoped && before !== '' && !Number.isFinite(new Date(before).getTime())) || (scope === 'before' && before === '')} onClick={() => void act('preview', { operation, scope, ...(timeScoped && before !== '' ? { before: new Date(before).toISOString() } : {}) })}>{t.preview}</button>
       {preview && <div style={{ ...style, display: 'flex', flexDirection: 'column', gap: 9 }}>
         <strong>{t.count(preview.counts.workspaces, preview.counts.sessions)}</strong>
         {preview.before && <span>{t.time}: {new Date(preview.before).toLocaleString()}</span>}

package/src/crew-workspaces.mjs

@@ -0,0 +1,136 @@
+// The two stable workspaces a Crew job runs in, one pair per project.
+//
+// Every job used to get its own git worktree named `Crew_<date>_<time>_<role>`,
+// so the Harness — which groups sessions by the job's cwd, and matches the
+// workspace exactly (`resolveByPath`, never a parent directory) — grew a new
+// workspace entry for every job an operator ran. A pair that is created once and
+// reused means the session list stops growing: a worker job and its automatic
+// review both run in `dsh-crew-worker` (the reviewer has to see the tree the
+// worker produced), and an explicit reviewer dispatch runs in `dsh-crew-review`.
+//
+// Two cwds per project, never shared between projects: a worktree belongs to one
+// repository, so the pair is namespaced under a key derived from the repository
+// path.
+//
+// Because the workspace outlives the job, two jobs sharing it would corrupt each
+// other's evidence — see `workspace-lock.mjs`, which this takes for the whole
+// job, and the reset below, which is what keeps a job from inheriting the last
+// one's work.
+
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { basename, join, resolve, sep } from 'node:path';
+
+import {
+  createWorktreeAt,
+  crewOwnsWorktree,
+  defaultWorktreeRoot,
+  inspectRepository,
+  resetWorktreeTo,
+} from './workspace-isolation.mjs';
+import { acquireWorkspaceLock, DEFAULT_LOCK_WAIT_MS } from './workspace-lock.mjs';
+
+export const CREW_WORKSPACE_WORKER = 'dsh-crew-worker';
+export const CREW_WORKSPACE_REVIEW = 'dsh-crew-review';
+export const CREW_WORKSPACE_NAMES = Object.freeze([CREW_WORKSPACE_WORKER, CREW_WORKSPACE_REVIEW]);
+export const WORKSPACE_CONFLICT = 'WORKSPACE_CONFLICT';
+
+/** The workspace a role runs in. Only the reviewer is separated out. */
+export function crewWorkspaceName(role) {
+  return role === 'reviewer' || role === 'review' ? CREW_WORKSPACE_REVIEW : CREW_WORKSPACE_WORKER;
+}
+
+/** Is this directory name one of the two stable workspaces? */
+export function isCrewWorkspaceName(name) {
+  return CREW_WORKSPACE_NAMES.includes(String(name ?? ''));
+}
+
+/**
+ * A stable, filesystem-safe key for a repository.
+ *
+ * Two projects' `dsh-crew-worker` directories must not collide, and the human
+ * part is kept because the key is visible in the session path: the directory
+ * name plus eight hex characters of the resolved path, the same shape the legacy
+ * worktree names used.
+ */
+export function crewProjectKey(repoRoot) {
+  const identity = resolve(String(repoRoot ?? '')).split(sep).join('/');
+  const normalized = process.platform === 'win32' ? identity.toLowerCase() : identity;
+  const safe = basename(identity).replace(/[^A-Za-z0-9]+/g, '-').slice(0, 32).replace(/^-+|-+$/g, '') || 'project';
+  const digest = createHash('sha256').update(normalized).digest('hex').slice(0, 8);
+  return `dsh-crew-${safe}-${digest}`;
+}
+
+/** `<worktreeRoot>/<projectKey>/<name>` — where this project's pair lives. */
+export function crewWorkspacePath({ repoRoot, role, root = defaultWorktreeRoot() } = {}) {
+  return join(resolve(root), crewProjectKey(repoRoot), crewWorkspaceName(role));
+}
+
+/** The lock for a workspace lives beside the pair, never inside the tree. */
+export function crewWorkspaceLockPath({ repoRoot, role, root = defaultWorktreeRoot() } = {}) {
+  return join(resolve(root), crewProjectKey(repoRoot), '.locks', `${crewWorkspaceName(role)}.lock`);
+}
+
+/**
+ * The workspace this job should run in, held for the job's duration.
+ *
+ * Creates the pair member on first use and adopts it afterwards; the adopted
+ * tree is reset to the job's base revision so the candidate diff is this job's
+ * work alone, exactly as a fresh worktree gave it. Returns a `release` that
+ * drops the lock but leaves the directory — the next job reuses it.
+ */
+export async function ensureCrewWorkspace({
+  cwd,
+  role,
+  baseRevision,
+  at,
+  root = defaultWorktreeRoot(),
+  git,
+  lockWaitMs = DEFAULT_LOCK_WAIT_MS,
+  now,
+  sleep,
+  isAlive,
+  pid,
+} = {}) {
+  const repo = await inspectRepository({ cwd, git });
+  if (!repo.ok) return { ok: false, reason: repo.reason, error: repo.error };
+  const repoRoot = repo.repoRoot;
+  const revision = baseRevision ?? repo.baseRevision;
+  const name = crewWorkspaceName(role);
+  const worktreePath = crewWorkspacePath({ repoRoot, role, root });
+  const lockPath = crewWorkspaceLockPath({ repoRoot, role, root });
+
+  const lock = await acquireWorkspaceLock({ lockPath, purpose: name, waitMs: lockWaitMs, now, sleep, isAlive, pid });
+  if (!lock.ok) return { ok: false, reason: lock.reason, error: lock.error, holder: lock.holder ?? null };
+  const release = lock.release;
+
+  const fail = (reason, error) => {
+    release();
+    return { ok: false, reason, error };
+  };
+
+  const reused = await crewOwnsWorktree({ worktreePath, repoRoot, git });
+  if (!reused) {
+    if (existsSync(worktreePath)) {
+      // Something is there that Crew did not create. Deleting it would be a
+      // destructive guess about a directory Crew cannot claim, so refuse and
+      // say which path is in the way.
+      return fail(WORKSPACE_CONFLICT, `workspace path exists but is not a Crew worktree of this repository: ${worktreePath}`);
+    }
+    const created = await createWorktreeAt({ dir: worktreePath, repoRoot, revision, purpose: name, at, git });
+    if (!created.ok) return fail(created.reason, created.error);
+  }
+
+  const reset = await resetWorktreeTo({ worktreePath, revision, git });
+  if (!reset.ok) return fail(reset.reason, reset.error);
+
+  return { ok: true, worktreePath, repoRoot, baseRevision: revision, name, reused, release };
+}
+
+/**
+ * Release the lock a job held. The directory stays: it is the workspace the
+ * next job — and every session it produced — belongs to.
+ */
+export function releaseCrewWorkspace(handle) {
+  try { return handle?.release?.() === true; } catch { return false; }
+}

package/src/history/cleanup-plan.mjs

@@ -31,14 +31,24 @@ function records(values) {
 /**
  * Pure preview only. No filesystem or project-path operations are performed.
  *
- * `scope` defaults to `crew`: a caller that forgets to narrow the range gets the
- * one range that cannot remove sessions the operator opened themselves. Widening
- * to `all` is always an explicit choice.
+ * `scope` defaults to `worktree` — Crew's own workspaces — because that is the
+ * range an operator is actually asking for when they clear a Crew project out,
+ * and it still cannot remove a session the operator opened themselves or one
+ * Crew ran in someone else's directory. Widening to `all` is always explicit.
+ *
+ * The value is named `worktree` for compatibility and now means workspaces: the
+ * pair a project's jobs run in, plus the per-job trees earlier releases left
+ * behind, so those stay cleanable instead of being stranded by the change.
  */
-export function planHistoryCleanup(snapshot, { operation = 'archive', scope = 'crew', before } = {}) {
+export function planHistoryCleanup(snapshot, { operation = 'archive', scope = 'worktree', before } = {}) {
   if (!['archive', 'delete'].includes(operation) || !['all', 'crew', 'worktree', 'before'].includes(scope)) throw new Error('HISTORY_INVALID_OPTIONS');
-  const cutoff = scope === 'before' ? instant(before) : null;
+  // `worktree` takes the same time window as `before`, but optionally: the panel
+  // supplies one when the operator picks a date, and its absence means "everything
+  // in these workspaces" rather than an error. A date that was supplied and is
+  // malformed still fails, so a typo cannot silently widen the range.
+  const cutoff = (scope === 'before' || scope === 'worktree') ? instant(before) : null;
   if (scope === 'before' && (typeof before !== 'string' || cutoff === null)) throw new Error('HISTORY_INVALID_CUTOFF');
+  if (scope === 'worktree' && before !== undefined && cutoff === null) throw new Error('HISTORY_INVALID_CUTOFF');
   const workspaces = records(snapshot.workspaces);
   const sessions = records(snapshot.sessions);
   const active = ids(snapshot.activeSessionIds);

package/src/hub/index.mjs

@@ -27,10 +27,11 @@ import { boundedMachineCodeFromError } from '../structured-error-code.mjs';
 import { createCanonicalJobEvent, projectWorkflowView } from '../job-contracts.mjs';
 import { getHubRuntimeIdentity } from '../runtime-identity.mjs';
 import { loadCiEvidence } from '../ci-evidence.mjs';
+import { ensureCrewWorkspace, releaseCrewWorkspace } from '../crew-workspaces.mjs';
 import { loadRoleProfiles, resolveRoleProfile, saveRoleProfiles } from '../role-profiles.mjs';
 import { addContextReferences, buildWorkspaceTask, isSafeBranchName, loadWorkspaceContexts, resolveWorkspaceContext, saveWorkspaceContexts } from '../workspace-context.mjs';
 import { buildExtensionContract } from '../extension-contract.mjs';
-import { cleanupIsolatedWorkspace, createIsolatedWorkspace, isCrewWorktreeName } from '../workspace-isolation.mjs';
+import { cleanupIsolatedWorkspace, isCrewWorktreeName } from '../workspace-isolation.mjs';
 import { jobDisplayName } from '../job-identity.mjs';
 import { assessWorkspaceReadiness } from '../workspace-readiness.mjs';
 import { buildConfigReadinessMatrix } from '../config-readiness.mjs';
@@ -861,26 +862,45 @@ export class WorkerRegistry {  constructor(ctx) {
     let executionCwd = cwd;
     let isolatedWorkspace = null;
     if ((requested_isolation === 'worktree' && jobRole === 'worker') || requested_isolation === 'readonly') {
-      const created = await createIsolatedWorkspace({ cwd, jobId: id, purpose: jobRole, baseRevision: workspace_branch });
+      // This project's stable worker/reviewer workspace, reset to the job's base
+      // revision and held for the job's duration, so the Harness groups these
+      // sessions into two entries instead of one per job.
+      const created = await ensureCrewWorkspace({ cwd, role: jobRole, baseRevision: workspace_branch });
       if (!created.ok) throw Object.assign(new Error(created.error ?? created.reason), { code: created.reason });
       executionCwd = created.worktreePath;
-      isolatedWorkspace = { worktreePath: created.worktreePath, repoRoot: created.repoRoot };
+      isolatedWorkspace = { worktreePath: created.worktreePath, repoRoot: created.repoRoot, stable: true, release: created.release };
     }
     // The Harness titles the session from the opening words of the prompt the
-    // agent receives, so the prompt opens with the job's Crew name: that makes the
-    // conversation, the worktree directory and the name an operator types the same
-    // string. An allocated worktree's name wins, so a collision suffix stays
-    // consistent between the two.
-    const jobName = isCrewWorktreeName(basename(executionCwd))
-      ? basename(executionCwd)
-      : jobDisplayName({ purpose: jobRole });
-    const workerPrompt = appendDeliveryInstructions(prependJobIdentity(task, { name: jobName, role: jobRole }), { tier: effTier, role: jobRole, isReview: delivery === 'review' || jobRole === 'reviewer' });
-
-    const sessionId = `session-${randomUUID()}`;
-    // Record provenance while it is still knowable: a session header carries no
-    // field naming who asked for the session, so a later Crew-scoped cleanup can
-    // only tell Crew's own work apart from the operator's by this ledger.
-    appendSessionOrigin({ sessionId, role: jobRole, jobId: id });
+    // agent receives, so the prompt opens with the job's Crew name. An allocated
+    // worktree's name wins, so a collision suffix stays consistent between the
+    // two. A stable workspace deliberately does *not* win: its directory name is
+    // shared by every job that uses it, so naming jobs after it would give them
+    // all one title and leave an operator unable to tell them apart. The
+    // workspace groups; the job name distinguishes.
+    let jobName;
+    let workerPrompt;
+    let sessionId;
+    try {
+      jobName = isCrewWorktreeName(basename(executionCwd))
+        ? basename(executionCwd)
+        : jobDisplayName({ purpose: jobRole });
+      workerPrompt = appendDeliveryInstructions(prependJobIdentity(task, { name: jobName, role: jobRole }), { tier: effTier, role: jobRole, isReview: delivery === 'review' || jobRole === 'reviewer' });
+
+      sessionId = `session-${randomUUID()}`;
+      // Record provenance while it is still knowable: a session header carries no
+      // field naming who asked for the session, so a later Crew-scoped cleanup can
+      // only tell Crew's own work apart from the operator's by this ledger.
+      appendSessionOrigin({ sessionId, role: jobRole, jobId: id });
+    } catch (error) {
+      // Everything below this point runs inside the job's own lifecycle, whose
+      // `finally` releases the workspace lock. A throw here happens before that
+      // job exists, so nothing would release a lock already taken — and it would
+      // then block the workspace until the age backstop, which is hours. The
+      // window is small (`appendSessionOrigin` writes a file) but the cost of
+      // missing it is a workspace no job can use.
+      releaseCrewWorkspace(isolatedWorkspace);
+      throw error;
+    }
     const job = {
       id, client_job_id: client_job_id ?? null, sessionId, role: jobRole, attempt, tier: effTier, provider: selection.provider, model: selection.model,
       selection_source: selection.source, selection_trace: selection.selection_trace ?? null,
@@ -1158,7 +1178,14 @@ export class WorkerRegistry {  constructor(ctx) {
           review: job.review,
           workspaceDiff: job.workspaceDiff,
         });
-        if (job.isolatedWorkspace) {
+        if (job.isolatedWorkspace?.stable === 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.
+          const released = releaseCrewWorkspace(job.isolatedWorkspace);
+          job.workspace_retained = false;
+          const workspaceCleanupWarning = released ? null : 'workspace lock was not held at release';
+          job.cleanup_warning = [handleCleanupWarning, workspaceCleanupWarning].filter(Boolean).join('; ') || null;
+        } else if (job.isolatedWorkspace) {
           const cleanup = await cleanupIsolatedWorkspace(job.isolatedWorkspace).catch((error) => ({ ok: false, error: error?.message ?? String(error) }));
           job.workspace_retained = cleanup.ok !== true;
           const workspaceCleanupWarning = cleanup.ok === true ? null : cleanup.error ?? 'worktree cleanup failed';

package/src/job-identity.mjs

@@ -7,10 +7,17 @@
 // 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;

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/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.0';
 export const HUB_PROTOCOL_VERSION = 1;
 
 export const HUB_CAPABILITIES = Object.freeze([

package/src/workspace-isolation.mjs

@@ -645,6 +645,73 @@ async function ownershipDrift(run, worktreePath, expect) {
 export const WORKTREE_CLEANUP_RETRIES = 3;
 export 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,
   repoRoot,

package/src/workspace-lock.mjs

@@ -0,0 +1,135 @@
+// One job at a time per Crew workspace.
+//
+// A stable workspace is shared by every job that uses it, which is the point —
+// the sessions group under one directory instead of multiplying. The cost is
+// that two jobs running in it at once would corrupt each other's evidence: the
+// client only captures a candidate for `worktree` isolation, the Hub diffs the
+// whole tree before and after and would attribute a concurrent job's edits to
+// this one, and the reviewer's before/after fingerprint would see the other
+// job's writes as a mutated candidate and force `request_changes`. Nothing in
+// the runtime serialised by directory before, so this does.
+//
+// The lock lives beside the workspace, never inside it: a file in the tree would
+// show up in the very diffs it is there to keep clean.
+//
+// It fails closed. A holder that died leaves a lock behind, so an obviously
+// abandoned one (its process is gone, or it has held the lock past any plausible
+// job) is reclaimed; but a lock whose owner still looks alive is waited for and
+// then refused with `WORKSPACE_BUSY`, never taken by force. Waiting is bounded,
+// and the bound is part of the caller's attempt budget.
+
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+export const WORKSPACE_BUSY = 'WORKSPACE_BUSY';
+export const WORKSPACE_LOCK_FILE = 'workspace.lock';
+export const WORKSPACE_LOCK_SCHEMA = 1;
+
+export const DEFAULT_LOCK_WAIT_MS = 120_000;
+export const DEFAULT_LOCK_POLL_MS = 500;
+// The two reasons a lock outlives its job are not the same, and they are covered
+// by different things. A holder whose process died is caught immediately by the
+// pid check below. This bound covers the other case — the process is alive but
+// the job is gone, which is what a job that ended without releasing looks like —
+// and it is only a backstop, so it wants to be as short as it can safely be.
+//
+// It must still exceed the longest a job may legitimately run, or a live job
+// would lose its own workspace: `timeout_seconds` is capped at 2h, so this is
+// that plus half an hour of margin. Six hours, the first value here, would have
+// stalled a workspace for four hours longer than any job can last.
+export const DEFAULT_LOCK_MAX_HOLD_MS = (2 * 60 + 30) * 60 * 1000;
+
+const defaultSleep = (ms) => new Promise((resolve) => { setTimeout(resolve, ms); });
+
+/** Is a process with this pid running? Unknown pids read as dead. */
+function defaultIsAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM means it exists and belongs to someone else; ESRCH means it is gone.
+    return error?.code === 'EPERM';
+  }
+}
+
+function readRecord(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Acquire the workspace lock, waiting up to `waitMs` for a live holder.
+ *
+ * Returns `{ ok: true, release }` or `{ ok: false, reason, error, holder }`.
+ * `release` only removes the lock this call created: after a reclaim, a stale
+ * holder waking up must not delete its successor's lock.
+ */
+export async function acquireWorkspaceLock({
+  lockPath,
+  purpose = null,
+  waitMs = DEFAULT_LOCK_WAIT_MS,
+  pollMs = DEFAULT_LOCK_POLL_MS,
+  maxHoldMs = DEFAULT_LOCK_MAX_HOLD_MS,
+  pid = process.pid,
+  now = Date.now,
+  sleep = defaultSleep,
+  isAlive = defaultIsAlive,
+} = {}) {
+  if (typeof lockPath !== 'string' || lockPath === '') {
+    return { ok: false, reason: WORKSPACE_BUSY, error: 'workspace lock requires a path' };
+  }
+  const deadline = now() + Math.max(0, waitMs);
+  const nonce = randomBytes(16).toString('hex');
+
+  for (;;) {
+    try {
+      mkdirSync(dirname(lockPath), { recursive: true });
+      writeFileSync(lockPath, `${JSON.stringify({
+        schemaVersion: WORKSPACE_LOCK_SCHEMA,
+        pid,
+        purpose,
+        nonce,
+        startedAt: now(),
+      })}\n`, { flag: 'wx' });
+      return {
+        ok: true,
+        release: () => {
+          const held = readRecord(lockPath);
+          if (held?.nonce !== nonce) return false;
+          try { rmSync(lockPath, { force: true }); return true; } catch { return false; }
+        },
+      };
+    } catch (error) {
+      if (error?.code !== 'EEXIST') {
+        return { ok: false, reason: WORKSPACE_BUSY, error: `cannot take workspace lock: ${error?.message ?? error}` };
+      }
+    }
+
+    const holder = readRecord(lockPath);
+    const startedAt = Number.isFinite(holder?.startedAt) ? holder.startedAt : null;
+    const abandoned = holder === null
+      || !isAlive(holder.pid)
+      || (startedAt !== null && now() - startedAt > maxHoldMs);
+    if (abandoned) {
+      // Reclaim and loop: the exclusive create on the next pass decides the
+      // race, so two waiters cannot both take it.
+      try { rmSync(lockPath, { force: true }); } catch { /* the retry decides */ }
+      continue;
+    }
+    if (now() >= deadline) {
+      return {
+        ok: false,
+        reason: WORKSPACE_BUSY,
+        error: `workspace is held by another job (pid ${holder.pid}${holder.purpose ? `, ${holder.purpose}` : ''})`,
+        holder,
+      };
+    }
+    await sleep(Math.min(pollMs, Math.max(1, deadline - now())));
+  }
+}