@ran-sh/dsh-crew 1.3.0 → 1.3.2

package/.claude-plugin/plugin.json

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

package/package.json

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

package/src/dsh-cli-runtime.mjs

@@ -784,6 +784,75 @@ function ensureProfileScaffold(profileRoot) {
   return changed;
 }
 
+function readPackageVersionAt(dir, read = readFileSync) {
+  try {
+    const parsed = JSON.parse(read(join(dir, 'package.json'), 'utf8'));
+    return typeof parsed.version === 'string' && parsed.version ? parsed.version : null;
+  } catch { return null; }
+}
+
+// Nearest `<dir>/node_modules/<name>` walking up from `dir`, mirroring the
+// resolution a require() from that directory would take.
+export function resolveNearestBundleVersion(dir, name, { exists = defaultExists, read = readFileSync } = {}) {
+  let cursor = dir;
+  for (let depth = 0; depth < 12; depth += 1) {
+    const candidate = join(cursor, 'node_modules', ...name.split('/'));
+    if (exists(candidate)) return readPackageVersionAt(candidate, read);
+    const parent = dirname(cursor);
+    if (parent === cursor) break;
+    cursor = parent;
+  }
+  return null;
+}
+
+/**
+ * Stop a profile from resolving its bundle packages out of a foreign cohort.
+ *
+ * A profile first installed against a source checkout records `dsh-base` and
+ * `dsh-web-app` as links into that checkout. Switching the CLI to another
+ * cohort leaves those links behind, and because they sit in the profile's own
+ * node_modules they shadow the matching packages installed beside the profile.
+ * The host then composes the web app of one cohort while the plugin table comes
+ * from another; the client module table is built per cohort, so the mismatched
+ * plugin dies at require time with "missed the module table".
+ *
+ * Only an entry whose fallthrough provably resolves the target cohort is
+ * removed. A profile that deliberately tracks a different cohort keeps its
+ * links and is reported as skipped, never as an error.
+ */
+export function reconcileProfileBundleCohort({
+  home = homedir(),
+  profileRoot,
+  version = TARGET_DSH_VERSION,
+  bundles = CREW_PROFILE_DEFAULT_BUNDLES,
+  exists = defaultExists,
+  read = readFileSync,
+  remove = (path) => rmSync(path, { recursive: true, force: true }),
+} = {}) {
+  const root = profileRoot ?? crewProfileDir({ home });
+  if (typeof root !== 'string' || !isAbsolute(root)) return { ok: false, code: 'INVALID_PROFILE_ROOT' };
+  const modulesDir = join(root, 'node_modules');
+  const parentDir = dirname(root);
+  const unshadowed = [];
+  const skipped = [];
+  const removeBundle = (path) => remove(path);
+  for (const name of bundles) {
+    const shadowPath = join(modulesDir, ...name.split('/'));
+    if (!exists(shadowPath)) continue;
+    const shadowed = readPackageVersionAt(shadowPath, read);
+    if (shadowed === version) continue;
+    const fallthrough = resolveNearestBundleVersion(parentDir, name, { exists, read });
+    if (fallthrough !== version) {
+      skipped.push({ bundle: name, shadowed: shadowed ?? null, fallthrough: fallthrough ?? null });
+      continue;
+    }
+    try { removeBundle(shadowPath); } catch { return { ok: false, code: 'PROFILE_BUNDLE_UNSHADOW_FAILED', profileRoot: root, bundle: name }; }
+    if (exists(shadowPath)) return { ok: false, code: 'PROFILE_BUNDLE_UNSHADOW_FAILED', profileRoot: root, bundle: name };
+    unshadowed.push({ bundle: name, shadowed: shadowed ?? null });
+  }
+  return { ok: true, changed: unshadowed.length > 0, profileRoot: root, unshadowed, skipped };
+}
+
 function readCrewTombstones(home) {
   const lifecycleFile = join(dirname(crewDshHome({ home })), 'provider-lifecycle.json');
   if (!existsSync(lifecycleFile)) return { ok: true, tombstones: {} };
@@ -894,9 +963,16 @@ export function ensurePluginRegistration({
 export function ensureCrewPluginRegistration({ home = homedir(), root, name } = {}) {
   const result = ensurePluginRegistration({ profileRoot: crewProfileDir({ home }), root, name });
   if (!result.ok) return result;
+  const reconciliation = reconcileProfileBundleCohort({ home, profileRoot: result.profileRoot });
+  if (!reconciliation.ok) return reconciliation;
   const reconciled = reconcileCrewProfileProviders({ home, profileRoot: result.profileRoot });
   if (!reconciled.ok) return reconciled;
-  return { ...result, changed: result.changed || reconciled.changed, provider_reconciliation: reconciled.removed ?? [] };
+  return {
+    ...result,
+    changed: result.changed || reconciled.changed || reconciliation.changed,
+    provider_reconciliation: reconciled.removed ?? [],
+    bundle_reconciliation: reconciliation.unshadowed ?? [],
+  };
 }
 
 /**

package/src/history/admission-gate.mjs

@@ -13,6 +13,22 @@ function method(object, name) {
   }
 }
 
+/**
+ * Whether one registered agent currently owns a running turn.
+ *
+ * Registration is not activity: the session controller resumes a session into
+ * the registry as soon as it opens it, and leaves it there after the turn ends
+ * with `status: 'idle'`. Treating a non-empty registry as "in use" therefore
+ * wedged cleanup permanently behind ACTIVE_SESSIONS on a machine whose web UI had
+ * ever opened a session. Only a `running` status means work is actually in
+ * flight; anything else (idle, or a status an older agent does not expose) is
+ * treated as not running, and `creating > 0` remains the independent guard for a
+ * creation that has not published yet.
+ */
+function isRunning(agent) {
+  try { return agent?.status === 'running'; } catch { return false; }
+}
+
 export function installHistoryAdmissionGate(agents, isMaintenancePending) {
   if (typeof agents?.create !== 'function' || typeof agents?.list !== 'function'
     || typeof isMaintenancePending !== 'function') throw new Error('HISTORY_ADMISSION_UNAVAILABLE');
@@ -40,7 +56,7 @@ export function installHistoryAdmissionGate(agents, isMaintenancePending) {
       if (entries.some(entry => method(agents, entry.name) !== entry.wrapper)) return false;
       try {
         const live = agents.list();
-        return Array.isArray(live) && creating === 0 && live.length === 0;
+        return Array.isArray(live) && creating === 0 && !live.some(isRunning);
       } catch { return false; }
     },
     dispose() {

package/src/history/archive-store.mjs

@@ -26,10 +26,21 @@ function pathInside(root, relativePath) {
   return current;
 }
 
+// One canonical session artifact path. The jsonl backend keeps one immutable
+// file per Session format generation: `session.jsonl` for version 0 and
+// `session.vN.jsonl` (N >= 1) after that, each optionally zstd-compressed.
+// Sharing the shape between the inventory and the archive guard keeps both in
+// step when the backend's naming changes.
+export const SESSION_ARTIFACT_PATTERN = /^harness\/sessions\/[^/]+\/[^/]+\/session(?:\.v[1-9][0-9]*)?\.jsonl(?:\.zstd)?$/;
+
+export function isSessionArtifactPath(relativePath, sessionId) {
+  return typeof relativePath === 'string'
+    && SESSION_ARTIFACT_PATTERN.test(relativePath)
+    && relativePath.split('/')[3] === sessionId;
+}
+
 function artifactPath(root, file) {
-  if (!validId(file?.sessionId) || typeof file.relativePath !== 'string'
-    || !/^harness\/sessions\/[^/]+\/[^/]+\/session\.jsonl(?:\.zstd)?$/.test(file.relativePath)
-    || file.relativePath.split('/')[3] !== file.sessionId) fail('INVALID_ARTIFACT');
+  if (!validId(file?.sessionId) || !isSessionArtifactPath(file.relativePath, file.sessionId)) fail('INVALID_ARTIFACT');
   return pathInside(root, file.relativePath);
 }
 

package/src/history/service.mjs

@@ -3,36 +3,65 @@ import { existsSync, readdirSync } from 'node:fs';
 import { relative } from 'node:path';
 import { planHistoryCleanup } from './cleanup-plan.mjs';
 import { installHistoryAdmissionGate } from './admission-gate.mjs';
-import { historyHash, historyPath, readHistoryBytes, decodeWorkspaceStore, readHistoryManifest } from './archive-store.mjs';
+import { historyHash, historyPath, readHistoryBytes, decodeWorkspaceStore, readHistoryManifest, isSessionArtifactPath } from './archive-store.mjs';
 import { readHistoryState, writeHistoryState, historyPending, publicHistoryState } from './state.mjs';
 
 export function createHistoryService({ crewRoot, agents, persistence, runtimeId, launch, now = Date.now }) {
   const gate = installHistoryAdmissionGate(agents, () => historyPending(crewRoot));
   const plans = new Map();
   let entering = false;
+  // One row per materialized session: the header to archive and the artifact
+  // location the backend reported. The 0.1.5 jsonl backend resolves each
+  // session's current immutable generation itself and hands back a concrete
+  // path through `listArtifacts()`. The earlier backend listed snapshots and
+  // only hinted at a location, leaving the encoding to be probed below.
+  async function readInventory() {
+    if (typeof persistence?.listArtifacts === 'function') {
+      const artifacts = await persistence.listArtifacts();
+      if (!Array.isArray(artifacts)) throw Error('HISTORY_INVENTORY_INVALID');
+      return artifacts.map(({ header, path }) => {
+        if (typeof path !== 'string') throw Error('HISTORY_STORAGE_UNSUPPORTED');
+        return { header, located: path, resolved: true };
+      });
+    }
+    if (typeof persistence?.listSnapshots === 'function') {
+      const rows = await persistence.listSnapshots();
+      if (!Array.isArray(rows)) throw Error('HISTORY_INVENTORY_INVALID');
+      return rows.map(({ header }) => {
+        const location = persistence.locate(header);
+        if (location?.kind !== 'jsonl') throw Error('HISTORY_STORAGE_UNSUPPORTED');
+        return { header, located: location.path, resolved: false };
+      });
+    }
+    throw Error('HISTORY_STORAGE_UNSUPPORTED');
+  }
   async function snapshot(options) {
-    if (typeof persistence?.listSnapshots !== 'function' || typeof persistence?.locate !== 'function'
-      || persistence.supportsRawArtifacts !== true) throw Error('HISTORY_STORAGE_UNSUPPORTED');
+    if (typeof persistence?.locate !== 'function') throw Error('HISTORY_STORAGE_UNSUPPORTED');
+    // Refuse only a backend that explicitly declares it exposes no per-session
+    // raw artifact. The 0.1.5 backend dropped the flag rather than setting it
+    // false, and the artifact path itself is validated below either way.
+    if (persistence.supportsRawArtifacts === false) throw Error('HISTORY_STORAGE_UNSUPPORTED');
     const bytes = readHistoryBytes(historyPath(crewRoot, 'harness/storages/workspace.json'));
     const store = decodeWorkspaceStore(bytes);
-    const listed = await persistence.listSnapshots();
-    if (!Array.isArray(listed) || listed.length > 10000) throw Error('HISTORY_INVENTORY_TOO_LARGE');
+    const listed = await readInventory();
+    if (listed.length > 10000) throw Error('HISTORY_INVENTORY_TOO_LARGE');
     let total = 0;
-    const sessions = listed.map(({ header, revision }) => {
+    const sessions = listed.map(({ header, located, resolved }) => {
       if (!header || typeof header.id !== 'string') throw Error('HISTORY_INVENTORY_INVALID');
-      const location = persistence.locate(header);
-      if (location?.kind !== 'jsonl') throw Error('HISTORY_STORAGE_UNSUPPORTED');
-      let path = relative(crewRoot, location.path).replaceAll('\\', '/');
-      if (!/^harness\/sessions\/[^/]+\/[^/]+\/session\.jsonl(?:\.zstd)?$/.test(path)
-        || path.split('/')[3] !== header.id) throw Error('HISTORY_STORAGE_UNSUPPORTED');
-      const plain = path.replace(/\.zstd$/, '');
-      const existing = [plain, `${plain}.zstd`].filter(candidate => existsSync(historyPath(crewRoot, candidate)));
-      if (existing.length !== 1) throw Error('HISTORY_ARTIFACT_AMBIGUOUS');
-      path = existing[0];
+      let path = relative(crewRoot, located).replaceAll('\\', '/');
+      if (!isSessionArtifactPath(path, header.id)) throw Error('HISTORY_STORAGE_UNSUPPORTED');
+      if (!resolved) {
+        // An unresolved location is a hint that may not name the encoding that
+        // actually exists, so exactly one candidate must be present on disk.
+        const plain = path.replace(/\.zstd$/, '');
+        const existing = [plain, `${plain}.zstd`].filter(candidate => existsSync(historyPath(crewRoot, candidate)));
+        if (existing.length !== 1) throw Error('HISTORY_ARTIFACT_AMBIGUOUS');
+        path = existing[0];
+      }
       const raw = readHistoryBytes(historyPath(crewRoot, path)); total += raw.length;
       if (total > 512 * 1024 * 1024) throw Error('HISTORY_INVENTORY_TOO_LARGE');
       return { id: header.id, createdAt: header.createdAt, parentSession: header.parentSession,
-        revision: JSON.stringify([revision, historyHash(raw)]), artifact: { sessionId: header.id, relativePath: path, sha256: historyHash(raw) } };
+        revision: JSON.stringify([header.revision, historyHash(raw)]), artifact: { sessionId: header.id, relativePath: path, sha256: historyHash(raw) } };
     });
     // A retained child keeps its ancestor chain; do not leave a newer fork orphaned.
     const workspaces = Object.entries(store.tables.workspaces).map(([id, row]) => ({ id, ...row }));

package/src/runtime-identity.mjs

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