dsh-bot-team 1.1.0 → 1.3.0

package/host/session-export.js

@@ -0,0 +1,22 @@
+/**
+ * Match @deepseek-ai/dsh-session-log-export's canonical JSONL format.
+ * Call only with the committed header/events from readBotSessionLog, never a
+ * prepared sessionQuery observation (which can append in-memory repair events).
+ * The header schema belongs to the native log format; event payloads are opaque.
+ */
+export function serializeBotSessionLog(header, events) {
+  const lines = [JSON.stringify({
+    type: 'session',
+    version: header.version,
+    id: header.id,
+    createdAt: header.createdAt,
+    ...(header.cwd !== undefined ? { cwd: header.cwd } : {}),
+    ...(header.parentSession !== undefined ? { parentSession: header.parentSession } : {}),
+    isSeeded: header.isSeeded,
+    ...(header.origin !== undefined ? { origin: header.origin } : {}),
+    delegationDepth: header.delegationDepth ?? 0,
+    ...(header.agentPreset !== undefined ? { agentPreset: header.agentPreset } : {}),
+  })];
+  for (const event of events) lines.push(JSON.stringify(event));
+  return lines.join('\n') + '\n';
+}

package/host/session-visibility.js

@@ -0,0 +1,147 @@
+import { inspectSessionHeader } from './native-session.js';
+
+const isSessionId = value => typeof value === 'string' && value.length > 0;
+
+/**
+ * One-way migration of ordinary Sessions already owned by Bot Team.
+ * New background/subagent Sessions are never archived. The workspace API owns
+ * activity checks; omitting stopActivity is essential to preserve running work.
+ */
+export class BotSessionVisibility {
+  constructor({ ctx, repo, logger, isBusy = () => false }) {
+    this.ctx = ctx;
+    this.repo = repo;
+    this.logger = logger;
+    this.isBusy = isBusy;
+    this.disposed = false;
+    // Ownership survives group/member removal once observed in the repository.
+    // Never populate this cache from global Session lists or archive responses.
+    this.owned = new Set();
+    this.completed = new Map();
+    this.busy = new Set();
+    this.inFlight = new Map();
+    this.activityRevision = new Map();
+    this.reportedErrors = new Map();
+    this.off = [
+      ctx.on('session/event', (session, event) => {
+        if (event?.type === 'turn/end' ||
+            (event?.type === 'goal/change' && event.data?.goal?.phase && event.data.goal.phase !== 'active')) {
+          return this.retryAfterActivity(session?.id);
+        }
+      }, { global: true }),
+      // turn/end is appended while the native loop still reports running.
+      ctx.on('agent/status', ({ agent, status }) => status === 'idle' ? this.retryAfterActivity(agent?.id) : undefined, { global: true }),
+      ctx.on('agent/disposed', ({ agent }) => this.retryAfterActivity(agent?.id), { global: true }),
+      ctx.on('goal/activation-changed', ({ sessionId, goal }) => {
+        // rc.3 emits only id/revision/activation here, not the goal phase.
+        if (!goal || goal.activation === 'disarmed') return this.retryAfterActivity(sessionId);
+      }, { global: true }),
+    ];
+    this.ready = this.reconcile();
+  }
+
+  collectOwnership() {
+    const add = id => { if (isSessionId(id)) this.owned.add(id); };
+    for (const binding of this.repo.sessionBindings?.values() || []) add(binding.sessionId);
+    for (const member of this.repo.members?.values() || []) {
+      add(member.sessionId);
+      if (Array.isArray(member.previousSessionIds)) for (const id of member.previousSessionIds) add(id);
+    }
+    for (const message of this.repo.messages?.values() || []) {
+      if (message.author?.type === 'bot') add(message.meta?.execution?.sessionId);
+    }
+  }
+
+  /** Refresh repository ownership; errors are returned and logged, never retried by timers. */
+  async reconcile() {
+    if (this.disposed) return [];
+    this.collectOwnership();
+    return Promise.all([...this.owned].map(sessionId => this.run(sessionId)));
+  }
+
+  retryAfterActivity(sessionId) {
+    if (this.disposed || !this.owned.has(sessionId) || this.completed.has(sessionId)) return;
+    // Remember a completion that races an in-flight busy response, but do not
+    // start work for arbitrary tracked IDs that have never been known busy.
+    if (this.inFlight.has(sessionId)) {
+      this.activityRevision.set(sessionId, (this.activityRevision.get(sessionId) || 0) + 1);
+      return this.inFlight.get(sessionId);
+    }
+    if (this.busy.has(sessionId)) return this.run(sessionId);
+  }
+
+  run(sessionId) {
+    if (this.disposed || !this.owned.has(sessionId)) return Promise.resolve({ sessionId, status: 'disposed' });
+    if (this.completed.has(sessionId)) return Promise.resolve({ sessionId, status: this.completed.get(sessionId) });
+    const existing = this.inFlight.get(sessionId);
+    if (existing) return existing;
+    // Start on a microtask so synchronous lifecycle notifications and concurrent
+    // reconcile calls share this entry before observation begins.
+    const pending = Promise.resolve().then(async () => {
+      let result;
+      do {
+        const revision = this.activityRevision.get(sessionId) || 0;
+        this.busy.delete(sessionId);
+        result = await this.archiveIdleOrdinary(sessionId);
+        if (result.status !== 'busy' || this.disposed || revision === (this.activityRevision.get(sessionId) || 0)) break;
+      } while (true);
+      return result;
+    }).finally(() => this.inFlight.delete(sessionId));
+    this.inFlight.set(sessionId, pending);
+    return pending;
+  }
+
+  async archiveIdleOrdinary(sessionId) {
+    const result = status => ({ sessionId, status });
+    if (this.disposed || !this.owned.has(sessionId)) return result('disposed');
+    try {
+      const header = await inspectSessionHeader(this.ctx, sessionId);
+      if (this.disposed || !this.owned.has(sessionId)) return result('disposed');
+      if (!header) return result('missing');
+      if (header.origin === 'subagent') {
+        this.completed.set(sessionId, 'subagent');
+        return result('subagent');
+      }
+      const agent = this.ctx.agents?.get?.(sessionId);
+      const goal = agent ? this.ctx.get?.('goals')?.get(agent) : undefined;
+      if (this.isBusy(sessionId) || agent?.status === 'running' ||
+          (goal?.phase === 'active' && goal.activation === 'armed')) {
+        this.busy.add(sessionId);
+        return result('busy');
+      }
+      const controller = this.ctx.get?.('workspaceController') || this.ctx.workspaceController;
+      if (typeof controller?.archiveSession !== 'function') throw new Error('Bot Team requires workspaceController.archiveSession for ordinary Session migration');
+      // Recheck after the asynchronous observation and immediately before the
+      // mutation. A removed group is still covered by the trusted ownership cache.
+      if (this.disposed || !this.owned.has(sessionId)) return result('disposed');
+      const archived = await controller.archiveSession({ sessionId });
+      if (!Array.isArray(archived?.archivedSessionIds) || !archived.archivedSessionIds.includes(sessionId)) {
+        throw new Error('Workspace archive response did not include the owned Bot Session');
+      }
+      this.completed.set(sessionId, 'archived');
+      this.reportedErrors.delete(sessionId);
+      return result('archived');
+    } catch (error) {
+      if (error?.code === 'workspace/session-active') {
+        if (!this.disposed) this.busy.add(sessionId);
+        return result('busy');
+      }
+      if (error?.code === 'session/not-found' || error?.code === 'SESSION_QUERY_SESSION_NOT_FOUND') return result('missing');
+      const description = String(error?.message || error);
+      const key = String(error?.code || '') + ':' + description;
+      if (this.reportedErrors.get(sessionId) !== key) {
+        this.reportedErrors.set(sessionId, key);
+        this.logger?.warn?.('bot-team: ordinary Session archive failed for ' + sessionId + ': ' + description);
+      }
+      return { ...result('error'), error };
+    }
+  }
+
+  /** Detach observation and await already-started calls; never stop native work. */
+  async dispose() {
+    this.disposed = true;
+    for (const off of this.off.splice(0)) off();
+    this.busy.clear();
+    await Promise.allSettled([...this.inFlight.values()]);
+  }
+}

package/host/storage-layout.js

@@ -0,0 +1,109 @@
+/**
+ * DSH 0.2 JSON storage accepts underscores in unit names, but not hyphens.
+ * Keep the legal unit name and relocate its physical directory, leaving a
+ * directory link for the backend (and older plugin versions) to follow.
+ */
+import path from 'node:path';
+import { lstat, mkdir, readlink, rename, symlink } from 'node:fs/promises';
+
+export const STORAGE_DIRECTORY_NAME = 'dsh-bot-team';
+
+async function inspect(target) {
+  try {
+    return await lstat(target);
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+/** Runs only while the storage domain is closed. Never merges two stores. */
+export async function relocateStorageDirectory(legacyDirectory) {
+  const legacy = path.resolve(legacyDirectory);
+  if (path.basename(legacy) !== 'bot_team') {
+    throw new Error(`bot-team: unexpected storage directory: ${legacy}`);
+  }
+  const root = path.dirname(legacy);
+  const target = path.join(root, STORAGE_DIRECTORY_NAME);
+  const [sourceInfo, targetInfo] = await Promise.all([inspect(legacy), inspect(target)]);
+  if (targetInfo && !targetInfo.isDirectory()) {
+    throw new Error(`bot-team: storage destination must be a real directory: ${target}`);
+  }
+  if (sourceInfo?.isSymbolicLink()) {
+    const destination = path.resolve(root, await readlink(legacy));
+    if (destination !== target || !targetInfo) {
+      throw new Error(`bot-team: unexpected or broken storage link: ${legacy} -> ${destination}`);
+    }
+    return target;
+  }
+  if (sourceInfo && !sourceInfo.isDirectory()) {
+    throw new Error(`bot-team: storage source is not a directory: ${legacy}`);
+  }
+  if (sourceInfo && targetInfo) {
+    throw new Error(`bot-team: both storage directories exist; resolve the conflict before enabling the plugin: ${legacy}, ${target}`);
+  }
+
+  if (sourceInfo) {
+    // Both paths are validated siblings; rename preserves all records and metadata.
+    await rename(legacy, target);
+  } else {
+    // Also resumes an interrupted migration that moved the directory already.
+    await mkdir(target, { recursive: true });
+  }
+  try {
+    // Windows junctions need an absolute target; POSIX links stay relocatable.
+    await symlink(process.platform === 'win32' ? target : STORAGE_DIRECTORY_NAME, legacy, process.platform === 'win32' ? 'junction' : 'dir');
+  } catch (error) {
+    // Restore the original location if creating the compatibility link failed.
+    // Never overwrite a source directory recreated by another process.
+    if (sourceInfo && !(await inspect(legacy))) {
+      try {
+        await rename(target, legacy);
+      } catch (rollbackError) {
+        throw new AggregateError([error, rollbackError], `bot-team: storage link creation and rollback failed; data remains at ${target}`);
+      }
+    }
+    throw error;
+  }
+  return target;
+}
+
+/**
+ * Isolate the installed DSH 0.2 JSON adapter's implementation-specific fields.
+ * The public domain API has no directory getter: resolve its configured route
+ * and require a recognized JSON backend instead of guessing DSH_HOME. This must
+ * precede open(), whose legacy single-file bootstrap can itself write records.
+ */
+export async function openPluginStorageDomain(storageDomain, spec, logger) {
+  const unsupported = () => new Error('bot-team: cannot resolve the JSON storage directory; this layout requires the DSH 0.2 per-record JSON backend');
+  const backendName = storageDomain.config?.routes?.[spec.name] ?? storageDomain.config?.backend;
+  const registry = storageDomain.ctx?.storage?.backend;
+  if (spec.name !== 'bot_team' || spec.layout !== 'per-record'
+    || typeof backendName !== 'string' || !backendName
+    || typeof registry?.get !== 'function' || typeof storageDomain.get !== 'function') {
+    throw unsupported();
+  }
+  const backend = registry.get(backendName);
+  if (backend?.constructor?.name !== 'JsonStorageBackend'
+    || typeof backend.root !== 'string' || !path.isAbsolute(backend.root)) {
+    throw unsupported();
+  }
+  // The previous plugin instance must finish close() and its write chain first.
+  // Do not close a domain owned by another still-active instance.
+  if (storageDomain.get(spec.name)) {
+    throw new Error('bot-team: storage domain is still open; disable the previous plugin instance before relocating its data');
+  }
+  const legacyDirectory = path.join(backend.root, spec.name);
+  const directory = await relocateStorageDirectory(legacyDirectory);
+  const domain = await storageDomain.open(spec);
+  const unit = domain.unit;
+  if (unit?.constructor?.name !== 'PerRecordJsonUnit'
+    || unit.descriptor?.name !== spec.name
+    || unit.descriptor?.layout !== 'per-record'
+    || unit.dir !== legacyDirectory) {
+    await domain.close();
+    throw unsupported();
+  }
+  logger?.info?.(`bot-team: storage directory ${directory}`);
+  return domain;
+}