@linxin666/dsh-client-ui-task-board 0.3.17 → 0.3.18

package/src/core/session-reuse.ts

@@ -0,0 +1,31 @@
+/**
+ * Session-reuse rule (issue #1419): decides which task runs continue in the
+ * previous execution's conversation. Pure, so the fail-closed conditions stay
+ * unit-testable without a gateway.
+ */
+import type { TaskRecord } from './tasks.ts'
+
+/**
+ * Pick the session a new execution of this task may continue in, or undefined
+ * to mint a fresh conversation. Reuse requires ALL of:
+ * - the task opted in (`reuseSession === true`);
+ * - the task's newest execution carries a session id and has settled (an open
+ *   execution would have made the ledger refuse the run in the first place);
+ * - the roster is known and that session is present and idle.
+ *
+ * An unknown roster (session/list unavailable) never reuses: minting a fresh
+ * conversation is always safe, prompting into a session we cannot see is not.
+ * @param task - the task about to run.
+ * @param idleSessionIds - ids the last roster saw as present and not running;
+ *   undefined when that roster is unknown.
+ * @returns the session id to continue in, or undefined for a fresh session.
+ */
+export function reusableSessionId(
+  task: TaskRecord,
+  idleSessionIds: ReadonlySet<string> | undefined,
+): string | undefined {
+  if (task.reuseSession !== true || idleSessionIds === undefined) return undefined
+  const last = task.executions[task.executions.length - 1]
+  if (last === undefined || last.sessionId === undefined || last.endedAt === undefined) return undefined
+  return idleSessionIds.has(last.sessionId) ? last.sessionId : undefined
+}

package/src/core/store.ts

@@ -65,6 +65,7 @@ function isTaskRecordShape(value: unknown): value is Omit<TaskRecord, 'status'>
   if (record.workspaceId !== undefined && typeof record.workspaceId !== 'string') return false
   if (record.mode !== undefined && typeof record.mode !== 'string') return false
   if (record.permission !== undefined && typeof record.permission !== 'string') return false
+  if (record.reuseSession !== undefined && typeof record.reuseSession !== 'boolean') return false
   if (!Array.isArray(record.executions)) return false
   for (const execution of record.executions) {
     if (typeof execution !== 'object' || execution === null) return false
@@ -185,6 +186,7 @@ export function parseLedger(raw: string | null): TaskRecord[] {
     task.mode = normalizeTargetId(row.mode)
     task.archivedAt = typeof row.archivedAt === 'number' && Number.isFinite(row.archivedAt) ? row.archivedAt : undefined
     task.permission = isTaskPermission(row.permission) ? row.permission as TaskPermission : undefined
+    task.reuseSession = row.reuseSession === true ? true : undefined
     task.freeze = normalizeFreeze(row.freeze)
     task.handover = normalizeHandover(row.handover)
     task.permissionConfirmedAt = typeof row.permissionConfirmedAt === 'number' && Number.isFinite(row.permissionConfirmedAt) ? row.permissionConfirmedAt : undefined

package/src/core/tasks.ts

@@ -137,6 +137,14 @@ export interface TaskRecord {
    * absent falls back to the host default (agent-default-model).
    */
   model?: string
+  /**
+   * Whether later executions continue in the previous execution's session
+   * (issue #1419) instead of minting a fresh conversation per run. Absent or
+   * false keeps the historical one-session-per-execution behavior; the reuse
+   * itself only happens when that session is idle and still present (see
+   * {@link reusableSessionId}).
+   */
+  reuseSession?: boolean
   /**
    * Frozen context snapshot for a continuation card; absent on plain tasks.
    * Sanitized before it enters the ledger (redaction, slash-command taint,
@@ -192,6 +200,8 @@ export interface NewTaskInput {
   permission?: TaskPermission
   /** Optional pinned model for the execution session; absent = host default. */
   model?: string
+  /** Reuse the previous execution's session for later runs (issue #1419). */
+  reuseSession?: boolean
   /**
    * Optional scheduled-run rule requested at creation time (the new-task
    * dialog): an enable flag plus a 5-field cron expression. The create use
@@ -279,6 +289,7 @@ export function createTask(input: NewTaskInput, now: number, id: string): TaskRe
     mode: normalizeTargetId(input.mode),
     permission: isTaskPermission(input.permission) ? input.permission : undefined,
     model: normalizeTargetId(input.model),
+    reuseSession: input.reuseSession === true ? true : undefined,
     ...(input.freeze === undefined ? {} : { freeze: freezeOf(input.freeze, now) }),
     ...(input.handover === undefined ? {} : { handover: { ...input.handover, bundledAt: now } }),
   }

package/src/core/use-cases/task-update.ts

@@ -16,7 +16,7 @@ import type { TaskHandoverInput } from '../handover.ts'
  * Editable fields on a task (the update patch surface). `freeze` replaces the
  * continuation-card snapshot (restamping frozenAt); an explicit null clears it.
  */
-export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model'>> & {
+export type TaskUpdatePatch = Partial<Pick<TaskRecord, 'title' | 'description' | 'prompt' | 'workspaceId' | 'mode' | 'permission' | 'model' | 'reuseSession'>> & {
   freeze?: FreezeSnapshot & { redacted?: boolean } | null
   /** Replaces the handover bundle (restamping bundledAt); an explicit null clears it. */
   handover?: TaskHandoverInput | null
@@ -93,6 +93,9 @@ export function applyUpdateTask(
     if (('permission' in patch && patch.permission !== undefined && patch.permission !== task.permission) || 'handover' in patch) {
       next.permissionConfirmedAt = undefined
     }
+    // Session reuse is a boolean opt-in; false (or an explicit null from a
+    // caller that needs to clear it) returns the task to one session per run.
+    if ('reuseSession' in patch) next.reuseSession = patch.reuseSession === true ? true : undefined
     if (workspaceId !== undefined || 'workspaceId' in patch) next.workspaceId = workspaceId
     if (mode !== undefined || 'mode' in patch) next.mode = mode
     if (permission !== undefined || 'permission' in patch) next.permission = permission

package/src/host-runner.ts

@@ -2,7 +2,7 @@ import type { TypertGateway } from '@deepseek-ai/dsh-api-gateway'
 import type { SessionAddress, SessionHistoryRecord, SessionListValue, SessionPage, SessionSummary } from '@deepseek-ai/dsh-api-session-controller/types'
 import type { CommandResult } from '@deepseek-ai/dsh-commands/types'
 import type { Workspace } from '@deepseek-ai/dsh-workspace/types'
-import type { TaskRecord } from './core/tasks.ts'
+import type { TaskPermission, TaskRecord } from './core/tasks.ts'
 
 /** Host services needed to validate a task's workspace before creating a session. */
 export interface TaskBoardWorkspaceRegistry {
@@ -171,7 +171,17 @@ export class HostExecutionRunner {
     return this.gateway.stream({ namespace, method, args: { request }, ...(signal === undefined ? {} : { signal }) })
   }
 
-  async launch(task: TaskRecord): Promise<string> {
+  /**
+   * Launch one execution. Without `options.reuseSessionId` a fresh session is
+   * created, renamed, pinned, and prompted (the historical contract). With it,
+   * the run continues in that existing session (issue #1419): the conversation
+   * keeps its title and history, the pinned permission/model are re-asserted so
+   * the task's execution contract still holds, and the prompt is queued.
+   * @param task - the task to run.
+   * @param options - optional session to continue in.
+   * @returns the session id the execution runs in.
+   */
+  async launch(task: TaskRecord, options: { reuseSessionId?: string } = {}): Promise<string> {
     // A handover bundle overrides the legacy pin fields: the bundle is the
     // authoritative execution triplet for a continuation card (issue #5).
     const workspaceId = task.handover?.workspaceId ?? task.workspaceId
@@ -189,6 +199,17 @@ export class HostExecutionRunner {
       if (preset === undefined) throw new Error('agent preset not found: ' + mode)
       if (preset.broken !== undefined) throw new Error('agent preset is unavailable: ' + preset.broken)
     }
+    // The ledger only ever stores ids minted by this runner (or the roster),
+    // so the brand is reasserted at this boundary instead of re-deriving it.
+    const reused = options.reuseSessionId as ExecutionSessionId | undefined
+    if (reused !== undefined) {
+      try {
+        await this.pinAndPrompt(reused, task, permission)
+      } catch (error) {
+        throw new SessionLaunchError(reused, error)
+      }
+      return reused
+    }
     const created = await this.invoke('session', 'create', {
       ...(workspaceId === undefined ? {} : { workspaceId }),
       ...(mode === undefined ? {} : { agentPreset: mode }),
@@ -196,39 +217,48 @@ export class HostExecutionRunner {
     const sessionId = created.sessionId
     try {
       await this.invoke('session', 'rename', { sessionId, title: task.title })
-      if (permission !== undefined) {
-        if (this.commands === undefined) throw new Error('permission command dispatcher is unavailable')
-        const command = await this.commands.execute(sessionId, '/permission ' + permission, AbortSignal.timeout(30_000))
-        if (command === undefined) throw new Error('permission command was not acknowledged')
-        if (command.kind !== 'success') throw new Error(command.text ?? 'permission command failed')
-      }
-      if (task.model !== undefined && task.model.trim() !== '') {
-        const rawModel = task.model.trim()
-        const slashIdx = rawModel.indexOf('/')
-        const provider = slashIdx >= 0 ? rawModel.slice(0, slashIdx).trim() : undefined
-        const modelId = slashIdx >= 0 ? rawModel.slice(slashIdx + 1).trim() : rawModel
-        try {
-          await this.invoke('session', 'selectModel', {
-            sessionId,
-            ...(provider ? { provider } : {}),
-            model: modelId,
-          })
-        } catch (modelError) {
-          console.warn(`[dsh-task-board] failed to select model "${task.model}" for session ${sessionId}, falling back to default:`, modelError)
-        }
-      }
-      await this.invoke('session', 'prompt', {
-        sessionId,
-        requestId: 'task-board-' + crypto.randomUUID(),
-        mode: 'queue' as const,
-        content: [{ type: 'text' as const, text: promptText(task) }],
-      })
+      await this.pinAndPrompt(sessionId, task, permission)
     } catch (error) {
       throw new SessionLaunchError(sessionId, error)
     }
     return sessionId
   }
 
+  /**
+   * Re-assert the pinned execution contract on a session and queue the task
+   * prompt. Shared by the fresh-session and reuse paths so both apply exactly
+   * the same permission/model pins before the prompt.
+   */
+  private async pinAndPrompt(sessionId: ExecutionSessionId, task: TaskRecord, permission: TaskPermission | undefined): Promise<void> {
+    if (permission !== undefined) {
+      if (this.commands === undefined) throw new Error('permission command dispatcher is unavailable')
+      const command = await this.commands.execute(sessionId, '/permission ' + permission, AbortSignal.timeout(30_000))
+      if (command === undefined) throw new Error('permission command was not acknowledged')
+      if (command.kind !== 'success') throw new Error(command.text ?? 'permission command failed')
+    }
+    if (task.model !== undefined && task.model.trim() !== '') {
+      const rawModel = task.model.trim()
+      const slashIdx = rawModel.indexOf('/')
+      const provider = slashIdx >= 0 ? rawModel.slice(0, slashIdx).trim() : undefined
+      const modelId = slashIdx >= 0 ? rawModel.slice(slashIdx + 1).trim() : rawModel
+      try {
+        await this.invoke('session', 'selectModel', {
+          sessionId,
+          ...(provider ? { provider } : {}),
+          model: modelId,
+        })
+      } catch (modelError) {
+        console.warn(`[dsh-task-board] failed to select model "${task.model}" for session ${sessionId}, falling back to default:`, modelError)
+      }
+    }
+    await this.invoke('session', 'prompt', {
+      sessionId,
+      requestId: 'task-board-' + crypto.randomUUID(),
+      mode: 'queue' as const,
+      content: [{ type: 'text' as const, text: promptText(task) }],
+    })
+  }
+
   async listRunning(): Promise<{ known: true; count: number; items: SessionSummary[] } | { known: false }> {
     for (let attempt = 1; ; attempt++) {
       try {

package/src/host-service.ts

@@ -1,5 +1,6 @@
 import type { TypertGateway } from '@deepseek-ai/dsh-api-gateway'
 import { nextRunAtMs } from './core/schedule.ts'
+import { reusableSessionId } from './core/session-reuse.ts'
 import { HostTaskLedger, type OpenedRun, type OpenExecutionReference } from './host-ledger.ts'
 import { HostExecutionRunner, SessionLaunchError, type SessionCommandDispatcher, type SessionSummary, type TaskBoardWorkspaceRegistry } from './host-runner.ts'
 import { PowerInhibitor } from './power-inhibitor.ts'
@@ -21,6 +22,13 @@ export class TaskBoardHostService {
   private pollInFlight = false
   private tickInFlight = false
   private active = true
+  /**
+   * Ids the last roster poll saw as present and idle; undefined while the
+   * roster is unknown. Session reuse (issue #1419) requires this positive
+   * evidence, so a launch before the first successful poll mints a fresh
+   * conversation instead of prompting into a session it cannot see.
+   */
+  private idleSessionIds: ReadonlySet<string> | undefined
   private preventIdleSleep = false
   private lastPowerJson = ''
   private readonly now: () => number
@@ -127,7 +135,8 @@ export class TaskBoardHostService {
 
   private async launch(opened: OpenedRun): Promise<void> {
     try {
-      const sessionId = await this.runner.launch(opened.task)
+      const reuseSessionId = reusableSessionId(opened.task, this.idleSessionIds)
+      const sessionId = await this.runner.launch(opened.task, reuseSessionId === undefined ? {} : { reuseSessionId })
       this.ledger.attachSession(opened.task.id, opened.execution.id, sessionId)
     } catch (error) {
       if (error instanceof SessionLaunchError) {
@@ -143,6 +152,7 @@ export class TaskBoardHostService {
     const running = await this.runner.listRunning()
     const previous = this.power.snapshot()
     if (!running.known) {
+      this.idleSessionIds = undefined
       this.power.updateReasons({
         runningSessions: previous.runningSessions,
         armedSchedules: this.ledger.armedScheduleCount(),
@@ -150,6 +160,7 @@ export class TaskBoardHostService {
       })
       return
     }
+    this.idleSessionIds = new Set(running.items.filter(item => !item.running).map(item => item.sessionId))
     // Read after the RPC so executions attached while it was in flight are
     // included in this pass, matching the former full-state snapshot timing.
     const runtime = this.ledger.runtimeView()

package/src/protocol.ts

@@ -157,6 +157,7 @@ function importedTask(value: unknown): TaskRecord | undefined {
     ...(task.workspaceId === undefined ? {} : { workspaceId: task.workspaceId }),
     ...(task.mode === undefined ? {} : { mode: task.mode }),
     ...(task.permission === undefined ? {} : { permission: task.permission }),
+    ...(task.reuseSession === undefined ? {} : { reuseSession: task.reuseSession }),
     ...(task.archivedAt === undefined ? {} : { archivedAt: task.archivedAt }),
     ...(task.freeze === undefined ? {} : { freeze: task.freeze }),
     ...(task.handover === undefined ? {} : { handover: task.handover }),
@@ -193,9 +194,10 @@ function handoverPayload(value: unknown): TaskHandoverInput | undefined {
 
 function createInput(value: unknown): value is NewTaskInput {
   const input = record(value)
-  if (input === undefined || !exactKeys(input, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'schedule', 'freeze', 'handover', 'model'])) return false
+  if (input === undefined || !exactKeys(input, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'schedule', 'freeze', 'handover', 'model', 'reuseSession'])) return false
   if (typeof input.title !== 'string' || typeof input.description !== 'string' || typeof input.prompt !== 'string') return false
   if (!optionalString(input.workspaceId) || !optionalString(input.mode) || !optionalString(input.model)) return false
+  if (input.reuseSession !== undefined && typeof input.reuseSession !== 'boolean') return false
   if (input.permission !== undefined && !isTaskPermission(input.permission)) return false
   if (input.freeze !== undefined && freezePayload(input.freeze) === undefined) return false
   if (input.handover !== undefined && handoverPayload(input.handover) === undefined) return false
@@ -209,7 +211,9 @@ function createInput(value: unknown): value is NewTaskInput {
 
 function updatePatch(value: unknown): boolean {
   const patch = record(value)
-  if (patch === undefined || !exactKeys(patch, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'freeze', 'handover', 'model'])) return false
+  if (patch === undefined || !exactKeys(patch, ['title', 'description', 'prompt', 'workspaceId', 'mode', 'permission', 'freeze', 'handover', 'model', 'reuseSession'])) return false
+  // null (or false) clears the reuse opt-in; only a real boolean is accepted.
+  if (patch.reuseSession !== undefined && patch.reuseSession !== null && typeof patch.reuseSession !== 'boolean') return false
   for (const key of ['title', 'description', 'prompt', 'workspaceId', 'mode', 'model'] as const) {
     if (!optionalString(patch[key])) return false
   }