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

package/src/client/board/TaskDetail.tsx

@@ -15,6 +15,7 @@ import { SCHEDULE_PRESETS } from '../schedule-presets.ts'
 import css from '../board.module.css'
 import { ConfirmDialog } from './ConfirmDialog.tsx'
 import { EditTaskModal } from './EditTaskModal.tsx'
+import { NewTaskModal } from './NewTaskModal.tsx'
 import { formatHostTimestamp, formatTime } from './TaskCard.tsx'
 import { STATUS_KEY } from './status-key.ts'
 
@@ -143,6 +144,16 @@ function ExecutionSettingsSection({ controller, task, pending }: { controller: B
           ))}
         </select>
       </label>
+      <label className={css.scheduleToggle}>
+        <input
+          type="checkbox"
+          checked={task.reuseSession === true}
+          disabled={pending}
+          onChange={event => { controller.updateTask(task.id, { reuseSession: event.target.checked }) }}
+        />
+        <span>{t('exec.reuseSession')}</span>
+      </label>
+      <p className={css.detailText}>{t('exec.reuseSessionHint')}</p>
     </section>
   )
 }
@@ -258,12 +269,16 @@ function ScheduleSection({ controller, task, pending }: { controller: BoardContr
 export function TaskDetail({ controller, task }: { controller: BoardController; task: TaskRecord }) {
   const [confirmDelete, setConfirmDelete] = useState(false)
   const [showEdit, setShowEdit] = useState(false)
+  const [showDuplicate, setShowDuplicate] = useState(false)
 
   // Keep the overlay in sync if the task record changes underneath.
   const [latest, setLatest] = useState(task)
   useEffect(() => { setLatest(task) }, [task])
   // A re-used overlay instance must not carry an edit session across tasks.
-  useEffect(() => { setShowEdit(false) }, [task.id])
+  useEffect(() => {
+    setShowEdit(false)
+    setShowDuplicate(false)
+  }, [task.id])
   const current = latest
   const snapshot = controller.getSnapshot()
   const running = current.status === 'running'
@@ -414,6 +429,17 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
               {t('detail.edit')}
             </button>
           )}
+          {!archived && (
+            <button
+              type="button"
+              className={css.ghostButton}
+              disabled={pending}
+              onClick={() => { setShowDuplicate(true) }}
+              title={canEditTaskContent(current) ? t('detail.duplicate') : t('detail.duplicateAndEdit')}
+            >
+              {canEditTaskContent(current) ? t('detail.duplicate') : t('detail.duplicateAndEdit')}
+            </button>
+          )}
           {!archived && (
             <button
               type="button"
@@ -485,6 +511,18 @@ export function TaskDetail({ controller, task }: { controller: BoardController;
       {showEdit && !archived && canEditTaskContent(current) && (
         <EditTaskModal controller={controller} task={current} onClose={() => { setShowEdit(false) }} />
       )}
+
+      {showDuplicate && !archived && (
+        <NewTaskModal
+          controller={controller}
+          initialTask={current}
+          onClose={() => { setShowDuplicate(false) }}
+          onDuplicateSuccess={async (sourceId) => {
+            await controller.archiveTask(sourceId)
+            controller.closeTask()
+          }}
+        />
+      )}
     </div>
   )
 }

package/src/client/locales.ts

@@ -60,9 +60,13 @@ export const zh = {
   'detail.permissionConfirmed': '已确认权限绑定 · {time}',
   'detail.title': '任务详情',
   'detail.edit': '编辑',
+  'detail.duplicate': '复制为新任务',
+  'detail.duplicateAndEdit': '修改并新建副本',
   'detail.close': '关闭',
   'edit.title': '编辑任务',
   'edit.save': '保存',
+  'new.duplicateTitle': '新建任务（副本）',
+  'new.archiveOriginal': '创建后归档原任务',
   'detail.prompt': '执行 Prompt',
   'detail.description': '描述',
   'detail.execution': '执行记录',
@@ -121,6 +125,8 @@ export const zh = {
   'exec.permission.danger-full-access': '完全访问',
   'exec.model.default': '宿主默认（agent-default-model）',
   'exec.model.unknown': '（未知模型/回退默认）',
+  'exec.reuseSession': '在同一对话继续',
+  'exec.reuseSessionHint': '开启后，本任务的后续执行在上一次会话里继续（该会话空闲且仍存在时），不再每次新建对话；每次复用时都会重新应用上面钉住的权限与模型。',
   'detail.executionSettings': '执行设置',
   'exec.hint': '执行时生效：工作区决定执行会话落在哪个工作区；模式决定会话的 agent 预设；权限经 /permission 命令应用到会话。留空则使用运行时默认。',
   // 插件设置卡片（settings.plugin.item 席位）。
@@ -208,9 +214,13 @@ export const en: Record<keyof typeof zh, string> = {
   'detail.permissionConfirmed': 'Permission confirmed · {time}',
   'detail.title': 'Task Detail',
   'detail.edit': 'Edit',
+  'detail.duplicate': 'Duplicate Task',
+  'detail.duplicateAndEdit': 'Edit as New Copy',
   'detail.close': 'Close',
   'edit.title': 'Edit Task',
   'edit.save': 'Save',
+  'new.duplicateTitle': 'New Task (Copy)',
+  'new.archiveOriginal': 'Archive original task upon creation',
   'detail.prompt': 'Run Prompt',
   'detail.description': 'Description',
   'detail.execution': 'Execution History',
@@ -269,6 +279,8 @@ export const en: Record<keyof typeof zh, string> = {
   'exec.permission.danger-full-access': 'Full Access',
   'exec.model.default': 'Host default (agent-default-model)',
   'exec.model.unknown': ' (unknown / fallback to default)',
+  'exec.reuseSession': 'Continue in the same conversation',
+  'exec.reuseSessionHint': 'When on, later runs continue in the previous session (when that session is idle and still exists) instead of starting a new conversation each time; the pinned permission and model above are re-applied on every reuse.',
   'detail.executionSettings': 'Execution Settings',
   'exec.hint': 'Applied when the task runs: the workspace decides where the execution session lands; the mode composes the session\'s agent preset; the permission is applied through the /permission command. Blank = runtime default.',
   // Plugin settings card (the `settings.plugin.item` seat).

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-ledger.ts

@@ -1,6 +1,6 @@
 import { spawnSync } from 'node:child_process'
 import { createHash } from 'node:crypto'
-import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { dshHome } from './dsh-home.ts'
 import { isValidCron, nextRunAtMs } from './core/schedule.ts'
@@ -286,6 +286,7 @@ export class HostTaskLedger {
     this.file = join(dir, 'ledger-v2.json')
     this.lockFile = join(dir, 'ledger-v2.lock')
     this.schedulerFile = join(dir, 'scheduler-v2.json')
+    this.cleanStaleTemporaryFiles(dir)
     this.lockFd = this.acquireLock()
     try {
       this.document = this.load(dir)
@@ -303,6 +304,24 @@ export class HostTaskLedger {
     }
   }
 
+  /** Remove leftover *.tmp-* files from previous crashes or interrupted writes. */
+  private cleanStaleTemporaryFiles(dir: string): void {
+    try {
+      const entries = readdirSync(dir)
+      for (const entry of entries) {
+        if (entry.includes('.tmp-')) {
+          try {
+            unlinkSync(join(dir, entry))
+          } catch {
+            // Best-effort cleanup
+          }
+        }
+      }
+    } catch {
+      // Directory may not exist yet or cannot be read
+    }
+  }
+
   /** Revision + scheduler without any task cloning; feeds the SSE event frame. */
   summary(): { revision: number; scheduler: TaskBoardSchedulerSnapshot } {
     const { importedSources: _imports, ...scheduler } = this.document.scheduler
@@ -443,7 +462,16 @@ export class HostTaskLedger {
     // tiny sidecar instead; any other patch still goes through the full
     // atomic commit.
     if (patch.lastTickAt !== undefined && Object.keys(patch).every(key => key === 'lastTickAt')) {
-      this.writeSchedulerSidecar()
+      try {
+        this.writeSchedulerSidecar()
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException)?.code === 'ENOSPC') {
+          // Disk is full; sidecar persistence fails, but in-memory heartbeat
+          // remains updated. Swallow to prevent unhandled log cascade crashes.
+          return
+        }
+        throw error
+      }
       return
     }
     this.commit(false)

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
@@ -37,6 +45,7 @@ export class TaskBoardHostService {
     this.runner = new HostExecutionRunner(gateway, options.commandDispatcher, options.workspaceRegistry)
     this.power = options.power ?? new PowerInhibitor()
     this.now = options.now ?? Date.now
+    installStreamErrorGuards()
     this.ledger.subscribe(() => {
       this.syncPowerReasons()
       this.emit()
@@ -127,7 +136,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 +153,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 +161,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()
@@ -203,7 +215,7 @@ export class TaskBoardHostService {
 
   private scheduleLaunch(opened: OpenedRun): void {
     void this.launch(opened).catch(error => {
-      console.error('[dsh-task-board] execution launch settlement failed', error)
+      safeConsoleError('[dsh-task-board] execution launch settlement failed', error)
     })
   }
 
@@ -211,7 +223,7 @@ export class TaskBoardHostService {
     if (this.pollInFlight || this.disposed) return
     this.pollInFlight = true
     void this.pollSessions().catch(error => {
-      console.error('[dsh-task-board] session polling failed', error)
+      safeConsoleError('[dsh-task-board] session polling failed', error)
     }).finally(() => { this.pollInFlight = false })
   }
 
@@ -219,7 +231,7 @@ export class TaskBoardHostService {
     if (this.tickInFlight || this.disposed) return
     this.tickInFlight = true
     void this.tickSchedule(first).catch(error => {
-      console.error('[dsh-task-board] scheduler tick failed', error)
+      safeConsoleError('[dsh-task-board] scheduler tick failed', error)
     }).finally(() => { this.tickInFlight = false })
   }
 
@@ -237,3 +249,33 @@ export class TaskBoardHostService {
     for (const listener of [...this.listeners]) listener()
   }
 }
+
+/**
+ * Install stream error listeners on process.stderr and process.stdout so that
+ * transient write failures (e.g. ENOSPC when the disk is full, or EPIPE on a
+ * closed pipe) never emit unhandled 'error' events that kill the Node.js host process.
+ */
+export function installStreamErrorGuards(): void {
+  for (const stream of [process.stderr, process.stdout]) {
+    if (stream && typeof stream.on === 'function') {
+      const hasErrorListener = typeof stream.listenerCount === 'function' && stream.listenerCount('error') > 0
+      if (!hasErrorListener) {
+        stream.on('error', () => {
+          // Swallow write stream errors to keep the host process alive
+        })
+      }
+    }
+  }
+}
+
+/**
+ * Defensively log to console.error without letting stderr write failures
+ * (e.g. ENOSPC from SyncWriteStream on redirected logs) crash the host process.
+ */
+export function safeConsoleError(message: string, ...args: unknown[]): void {
+  try {
+    console.error(message, ...args)
+  } catch {
+    // Best-effort stderr write; ignore write errors when stderr stream fails
+  }
+}

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
   }