dsh-session-mng 0.1.1 → 0.1.3

package/lib/service.js

@@ -12,7 +12,7 @@
 
 import { SessionMngError, messageOf } from './errors.js'
 import { normalizeTitle, proposeTitle, textOfEvent } from './title.js'
-import { buildState } from './state.js'
+import { buildState, classifySession } from './state.js'
 import {
   defaultSessionsRoot,
   dirSize,
@@ -134,12 +134,30 @@ function normalizeIds(value, max, label = 'sessionIds') {
   return ids
 }
 
-/** Walk a lineage tree and collect every descendant session id. */
-function collectDescendants(node, out) {
+/**
+ * Walk a lineage tree, splitting descendants into the two kinds the plugin
+ * treats differently.
+ *
+ * - `subagents` — delegation sessions; they belong to the root and are
+ *   cascaded with it.
+ * - `forks` — ordinary branches (including historical logs that still record
+ *   a parent). They are independent user sessions, so the walk records one and
+ *   stops: nothing below it may be cascaded with the root.
+ *
+ * @param {object} node - one `SessionLineageNode` returned by `traceSession`.
+ * @param {{ subagents: object[], forks: object[] }} out - accumulator.
+ */
+function partitionDescendants(node, out) {
   for (const child of node?.descendants ?? []) {
-    const id = child?.session?.header?.id
-    if (typeof id === 'string') out.push(id)
-    collectDescendants(child, out)
+    const record = child?.session
+    const id = record?.header?.id
+    if (typeof id !== 'string') continue
+    if (classifySession(record.header) === 'subagent') {
+      out.subagents.push(record)
+      partitionDescendants(child, out)
+    } else {
+      out.forks.push(record)
+    }
   }
   return out
 }
@@ -200,7 +218,7 @@ export function createService(ctx, config) {
     }
     try {
       const lineage = await trace.call(query(), id)
-      return collectDescendants(lineage, [])
+      return partitionDescendants(lineage, { subagents: [], forks: [] })
     } catch (error) {
       throw new SessionMngError('trace-failed', `could not trace descendants of "${id}": ${messageOf(error)}`, 500)
     }
@@ -441,9 +459,16 @@ export function createService(ctx, config) {
       throw new SessionMngError('unsupported-backend', 'permanent deletion requires the local JSONL session backend', 501)
     }
     const archived = new Set(archivedIds())
+    const selected = new Set(ids)
     const roots = []
     const errors = []
     const sessions = []
+    // Ordinary forks are independent sessions: they keep their own log when a
+    // parent is deleted and only lose the "from <parent>" label. Collect them
+    // separately so the confirmation can say so instead of silently cascading
+    // a user branch. A fork selected in this same batch is deleted on its own.
+    const forkChildren = []
+    const forkSeen = new Set()
     for (const rootId of ids) {
       try {
         if (!archived.has(rootId)) {
@@ -454,8 +479,18 @@ export function createService(ctx, config) {
         const snapshot = await store.stat(rootId)
         const header = snapshot?.header
         if (header === undefined) throw new SessionMngError('not-found', `session "${rootId}" is not stored`, 404)
-        const descendants = await descendantsOf(rootId)
-        const all = [rootId, ...descendants.filter((id) => id !== rootId)]
+        const lineage = await descendantsOf(rootId)
+        const all = [rootId, ...lineage.subagents.map((record) => record.header.id).filter((id) => id !== rootId)]
+        for (const record of lineage.forks) {
+          const forkId = record.header.id
+          if (selected.has(forkId) || forkSeen.has(forkId)) continue
+          forkSeen.add(forkId)
+          forkChildren.push({
+            id: forkId,
+            parentId: record.header.parentSession ?? rootId,
+            title: await readTitle(forkId),
+          })
+        }
         const rootRow = {
           id: rootId,
           title: await readTitle(rootId),
@@ -508,6 +543,7 @@ export function createService(ctx, config) {
       errors,
       sessions,
       descendantCount: roots.reduce((sum, root) => sum + root.descendantCount, 0),
+      forkChildren,
       totalBytes: sessions.reduce((sum, row) => sum + row.bytes, 0),
     }
   }
@@ -535,14 +571,17 @@ export function createService(ctx, config) {
           })
           continue
         }
-        let descendants
+        let lineage
         try {
-          descendants = await descendantsOf(rootId)
+          lineage = await descendantsOf(rootId)
         } catch (error) {
           failures.set(rootId, { sessionId: rootId, ok: false, error: resultError(error) })
           continue
         }
-        for (const id of [rootId, ...descendants]) {
+        // Only delegation sessions are cascaded. An ordinary fork (including a
+        // historical log that still records a parent) is an independent user
+        // session and stays where it is.
+        for (const id of [rootId, ...lineage.subagents.map((record) => record.header.id)]) {
           if (seen.has(id)) continue
           seen.add(id)
           const snapshot = await store.stat(id).catch(() => undefined)
@@ -732,13 +771,22 @@ export function createService(ctx, config) {
     if (serviceOf(ctx, 'agents')?.get?.(id)?.status === 'running') {
       throw new SessionMngError('session-running', 'this session is running; stop it before moving', 409)
     }
-    if (header.origin === 'subagent' || header.parentSession !== undefined) {
+    if (header.origin === 'subagent' || (typeof header.delegationDepth === 'number' && header.delegationDepth >= 1)) {
       throw new SessionMngError('subagent-session', 'subagent sessions are not moved on their own', 409)
     }
-    const descendants = await descendantsOf(id)
-    if (descendants.length > 0) {
+    if (header.parentSession !== undefined && header.parentSession !== null) {
+      throw new SessionMngError(
+        'branch-session',
+        "a branch session must stay in its parent's workspace, so it is not moved on its own",
+        409,
+      )
+    }
+    // Only subagent descendants block a move. An ordinary fork (historical or
+    // not) is an independent session, so it no longer blocks its source.
+    const lineage = await descendantsOf(id)
+    if (lineage.subagents.length > 0) {
       throw new SessionMngError('has-descendants', 'this session has subagent descendants; they cannot follow it yet', 409, {
-        descendants: descendants.length,
+        descendants: lineage.subagents.length,
       })
     }
     const source = workspaceOfId(id)

package/lib/state.js

@@ -140,10 +140,31 @@ function headerOf(row, snapshotsById, ctx) {
   return snapshotsById.get(row.sessionId)?.header
 }
 
-/** Whether a header/summary pair describes a subagent session. */
-function isSubagent(header, summary) {
-  if (header?.origin === 'subagent' || summary?.origin === 'subagent') return true
-  return Boolean(header?.parentSession ?? summary?.parentSessionId)
+/**
+ * Classify one session from whatever identifying fields are available.
+ *
+ * Callers pass a stored header, a list summary, or a merged view, so both
+ * field spellings are accepted (`parentSession` on a header, `parentSessionId`
+ * on a summary). Keeping this in one place is what makes the listing, the
+ * delete scope and the move guard agree on what an ordinary fork is: only
+ * delegation (`origin: 'subagent'` or a delegation depth) marks an internal
+ * session. A parent alone is not enough — an ordinary fork carries one too,
+ * and historical forks still record it.
+ */
+export function classifySession(fields) {
+  if (fields?.origin === 'subagent') return 'subagent'
+  if (typeof fields?.delegationDepth === 'number' && fields.delegationDepth >= 1) return 'subagent'
+  const parent = fields?.parentSession ?? fields?.parentSessionId
+  return parent === undefined || parent === null || parent === '' ? 'root' : 'fork'
+}
+
+/** Classify one row of the listing from its header and summary. */
+function classifyKind(header, summary) {
+  return classifySession({
+    origin: header?.origin ?? summary?.origin,
+    delegationDepth: header?.delegationDepth ?? summary?.delegationDepth,
+    parentSession: header?.parentSession ?? summary?.parentSessionId,
+  })
 }
 
 /**
@@ -201,6 +222,7 @@ export async function buildState(ctx, config, options = {}) {
   for (const id of snapshotById.keys()) knownIds.add(id)
   const rows = []
   const missingTitles = []
+  let hiddenSubagents = 0
 
   const pushRow = (base) => {
     const id = base.sessionId
@@ -208,8 +230,11 @@ export async function buildState(ctx, config, options = {}) {
     seen.add(id)
     const header = headerOf(base, snapshotById, ctx)
     const summary = base
-    const subagent = isSubagent(header, summary)
-    if (subagent && !includeSubagents) return
+    const kind = classifyKind(header, summary)
+    if (kind === 'subagent' && !includeSubagents) {
+      hiddenSubagents += 1
+      return
+    }
 
     const cwd = summary.cwd ?? header?.cwd ?? ''
     const workspace =
@@ -234,13 +259,15 @@ export async function buildState(ctx, config, options = {}) {
       running,
       blank: summary.blank === true,
       origin: header?.origin ?? summary.origin,
-      parentSessionId: header?.parentSession ?? summary.parentSessionId,
+      kind,
+      isSubagent: kind === 'subagent',
+      isFork: kind === 'fork',
+      parentSessionId: header?.parentSession ?? summary.parentSessionId ?? null,
       agentPreset: header?.agentPreset ?? '',
       createdAt: header?.createdAt ?? summary.updatedAt ?? 0,
       updatedAt: summary.updatedAt ?? header?.createdAt ?? 0,
       sizeBytes: typeof snapshot?.sizeBytes === 'number' ? snapshot.sizeBytes : 0,
       formatStatus: summary.formatStatus ?? snapshot?.formatStatus,
-      isSubagent: subagent,
     })
   }
 
@@ -268,6 +295,22 @@ export async function buildState(ctx, config, options = {}) {
     if (row.title === '') row.title = titles.get(row.id) ?? ''
   }
 
+  // A fork points at its parent by id only; resolving the title here lets the
+  // list show the relationship without a second round trip. `parentPresent`
+  // lets the client tell "untitled parent" apart from "the parent session is
+  // gone" (possible after the parent is permanently deleted).
+  const titlesById = new Map(rows.map((row) => [row.id, row.title]))
+  const forkCountByParent = new Map()
+  for (const row of rows) {
+    row.parentTitle = row.kind === 'fork' ? (titlesById.get(row.parentSessionId) ?? '') : ''
+    row.parentPresent = row.kind === 'fork' && titlesById.has(row.parentSessionId)
+    if (row.kind !== 'fork' || row.parentSessionId === null) continue
+    forkCountByParent.set(row.parentSessionId, (forkCountByParent.get(row.parentSessionId) ?? 0) + 1)
+  }
+  for (const row of rows) {
+    row.forkCount = forkCountByParent.get(row.id) ?? 0
+  }
+
   const jsonl =
     typeof ctx.sessionPersistence?.locate === 'function' && typeof ctx.sessionPersistence?.stat === 'function'
   const capabilities = {
@@ -282,7 +325,7 @@ export async function buildState(ctx, config, options = {}) {
       title: capabilities.title,
       archive: !row.archived,
       restore: row.archived,
-      move: capabilities.move && !row.live && !row.running && !row.isSubagent && row.parentSessionId === undefined,
+      move: capabilities.move && !row.live && !row.running && row.kind === 'root',
       delete: capabilities.delete && row.archived && !row.live,
       open: true,
     }
@@ -323,6 +366,8 @@ export async function buildState(ctx, config, options = {}) {
       active: rows.filter((row) => !row.archived).length,
       archived: rows.filter((row) => row.archived).length,
       subagents: rows.filter((row) => row.isSubagent).length,
+      hiddenSubagents,
+      forks: rows.filter((row) => row.isFork).length,
       bytes: totalBytes,
     },
     limits: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-mng",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "description": "Session management for DeepSeek Harness: one Settings page for every session — whole-session title generation, archive/restore, cross-workspace move, and permanent deletion of archived sessions.",
   "license": "MIT",
@@ -10,7 +10,7 @@
     "type": "git",
     "url": "git+https://github.com/ZilongYang/dsh-session-mng.git"
   },
-  "homepage": "https://github.com/ZilongYang/dsh-session-mng#readme",
+  "homepage": "https://dsh.zlmix.com/session-mng/",
   "bugs": {
     "url": "https://github.com/ZilongYang/dsh-session-mng/issues"
   },
@@ -71,7 +71,8 @@
     "compatibility": {
       "dsh": ">=0.2.0-rc.1 <0.3.0-0",
       "dshReleases": {
-        "0.2.1-rc.2": "compatible"
+        "0.2.1-rc.2": "compatible",
+        "0.2.1-rc.3": "compatible"
       }
     }
   }