dsh-taskboard 0.7.1 → 0.7.2

package/package.json

@@ -1,92 +1,91 @@
-{
-  "name": "dsh-taskboard",
-  "description": "Agent-first task board for the DSH web GUI: host-authoritative task ledger with taskboard_* agent tools, project (= workspace) claim boundaries, per-task model execution in fresh sessions, optional per-task git-worktree isolation (dedicated task branches, commit evidence, one-click merge), host-side cron scheduling, and a live SSE kanban view. Mounts via the official dsh plugin system — no DSH source changes.",
-  "version": "0.7.1",
-  "type": "module",
-  "main": "lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./invariant": "./lib/invariant.js",
-    "./client": "./lib/client.js",
-    "./package.json": "./package.json"
-  },
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    },
-    "client": {
-      "inject": [],
-      "platform": "web"
-    },
-    "compatibility": {
-      "dshReleases": {
-        "0.1.0-rc.8": "unknown",
-        "0.1.1-rc.1": "unknown",
-        "0.1.1-rc.2": "compatible",
-        "0.1.2-alpha.2": "compatible",
-        "0.1.2-alpha.3": "compatible",
-        "0.1.2-alpha.4": "compatible",
+{
+  "name": "dsh-taskboard",
+  "description": "Agent-first task board for the DSH web GUI: host-authoritative task ledger with taskboard_* agent tools, project (= workspace) claim boundaries, per-task model execution in fresh sessions, optional per-task git-worktree isolation (dedicated task branches, commit evidence, one-click merge), host-side cron scheduling, and a live SSE kanban view. Mounts via the official dsh plugin system — no DSH source changes.",
+  "version": "0.7.2",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./invariant": "./lib/invariant.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [],
+      "platform": "web"
+    },
+    "compatibility": {
+      "dshReleases": {
+        "0.1.0-rc.8": "unknown",
+        "0.1.1-rc.1": "unknown",
+        "0.1.1-rc.2": "compatible",
+        "0.1.2-alpha.2": "compatible",
+        "0.1.2-alpha.3": "compatible",
+        "0.1.2-alpha.4": "compatible",
         "0.1.2-alpha.5": "compatible",
         "0.1.2-rc.1": "compatible",
         "0.1.5-rc.1": "compatible"
-      }
-    }
-  },
-  "files": [
-    "lib/**/*.js",
-    "lib/**/*.js.map",
-    "src",
-    "cordis.patch.yml",
-    "LICENSE"
-  ],
-  "license": "Apache-2.0",
-  "engines": {
-    "node": ">=22"
-  },
-  "author": "cloader",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/cloader/dsh-taskboard.git"
-  },
-  "bugs": {
-    "url": "https://github.com/cloader/dsh-taskboard/issues"
-  },
-  "homepage": "https://github.com/cloader/dsh-taskboard#readme",
-  "keywords": [
-    "dsh",
-    "deepseek-harness",
-    "dsh-plugin",
-    "taskboard",
-    "kanban",
-    "agent"
-  ],
-  "scripts": {
-    "build": "node scripts/clean-lib.mjs && npm run build:host && npm run build:client",
-    "build:host": "tsdown -c tsdown.host.config.ts",
-    "build:client": "tsdown -c tsdown.client.config.ts && node scripts/wrap-client.mjs",
-    "watch": "tsdown -c tsdown.host.config.ts --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
-  },
-  "devDependencies": {
-    "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-agent": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-home-paths": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-host-webserver": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-workspace": "^0.1.5-rc.2",
-    "@deepseek-ai/schemastery": "^3.18.2",
-    "@types/node": "^22.20.1",
-    "@types/react": "~18.3.1",
-    "@types/react-dom": "^18.3.7",
-    "jsdom": "^25.0.1",
-    "puppeteer-core": "^25.8.0",
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1",
-    "tsdown": "0.22.2",
-    "typescript": "~5.7.2",
-    "vitest": "^3.0.0"
-  }
-}
-
+      }
+    }
+  },
+  "files": [
+    "lib/**/*.js",
+    "lib/**/*.js.map",
+    "src",
+    "cordis.patch.yml",
+    "LICENSE"
+  ],
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22"
+  },
+  "author": "cloader",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cloader/dsh-taskboard.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cloader/dsh-taskboard/issues"
+  },
+  "homepage": "https://github.com/cloader/dsh-taskboard#readme",
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "dsh-plugin",
+    "taskboard",
+    "kanban",
+    "agent"
+  ],
+  "scripts": {
+    "build": "node scripts/clean-lib.mjs && npm run build:host && npm run build:client",
+    "build:host": "tsdown -c tsdown.host.config.ts",
+    "build:client": "tsdown -c tsdown.client.config.ts && node scripts/wrap-client.mjs",
+    "watch": "tsdown -c tsdown.host.config.ts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-agent": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-home-paths": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-tools": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-workspace": "^0.1.5-rc.2",
+    "@deepseek-ai/schemastery": "^3.18.2",
+    "@types/node": "^22.20.1",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "^18.3.7",
+    "jsdom": "^25.0.1",
+    "puppeteer-core": "^25.8.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "tsdown": "0.22.2",
+    "typescript": "~5.7.2",
+    "vitest": "^3.0.0"
+  }
+}

package/src/host/execution.ts

@@ -6,7 +6,8 @@
  * prompt is submitted as an ordinary user message, and the turn settlement
  * (turn/end reason) is folded back into the task's execution record.
  *
- * Every execution is a NEW session: clean context, no reuse of previous runs.
+ * Manual runs open fresh sessions; scheduled runs can resume their previous
+ * session while keeping separate execution records and settlement watchers.
  *
  * @module dsh-taskboard/host/execution
  */
@@ -35,6 +36,8 @@ export const DEFAULT_MAX_CONCURRENT = 3
 
 /** Narrow agents face (the registry's create, structurally). */
 export interface AgentsFace {
+  /** Restore a compatible scheduled session; undefined means it is unavailable. */
+  resumeScheduled?(sessionId: string, options: Parameters<AgentsFace['create']>[0]): Promise<Awaited<ReturnType<AgentsFace['create']>> | undefined>
   create(options: {
     sessionId: string
     meta?: { cwd?: string; agentPreset?: string }
@@ -44,11 +47,15 @@ export interface AgentsFace {
   }): Promise<{
     agent: {
       id: string
+      /** Present on the real DSH agent; rechecked immediately before dispatch. */
+      readonly status?: 'idle' | 'running'
       followup(message: unknown): void
       inject(message: unknown): void
       whenIdle(): Promise<void>
     }
     dispose(): Promise<void>
+    /** Live sessions borrowed from another owner must survive cancelled startup. */
+    borrowed?: boolean
   }>
 }
 
@@ -269,15 +276,17 @@ export class ExecutionService {
    * releasing its run entry, so a success settlement can never race it into
    * the ledger and record a failed run as succeeded.
    */
-  private noteFailure(sessionId: string, message: string): Promise<void> {
+  private noteFailure(sessionId: string, message: string, executionId?: string): Promise<void> {
     // The failed session may already have committed work — collect the
     // evidence (best effort) BEFORE marking the execution failed (0.3.1).
-    const entry = [...this.runs.values()].find(e => e.sessionId === sessionId)
+    const match = [...this.runs.entries()].find(([id, e]) => e.sessionId === sessionId && (executionId === undefined || id === executionId))
+    if (match === undefined) return Promise.resolve()
+    const [failedId, entry] = match
     return this.collectEvidence(entry?.prepared).then(evidence =>
       this.deps.store.mutate('execution-recorded', (ledger) => {
         for (const task of ledger.tasks) {
           for (const execution of task.executions) {
-            if (execution.sessionId === sessionId && execution.outcome === 'running') {
+            if (execution.id === failedId && execution.outcome === 'running') {
               execution.outcome = 'failed'
               execution.error = message.slice(0, 500)
               execution.endedAt = this.deps.now()
@@ -355,7 +364,7 @@ export class ExecutionService {
     }
 
     const executionId = newExecutionId()
-    const sessionId = this.deps.mintSessionId?.() ?? `session-taskboard-${crypto.randomUUID()}`
+    let sessionId = this.deps.mintSessionId?.() ?? `session-taskboard-${crypto.randomUUID()}`
 
     // 0. Resolve code isolation (plan §3.2): explicit 'none' → zero git calls;
     //    'worktree' (also the omitted default) → prepare below, degrading to
@@ -372,7 +381,8 @@ export class ExecutionService {
         gate = `no task ${taskId}`
         return undefined
       }
-      if (target.status === 'in_progress') {
+      if (target.status === 'in_progress' || target.executions.some(e => e.outcome === 'running')
+        || [...this.runs.values()].some(e => target.executions.some(x => x.sessionId === e.sessionId))) {
         gate = 'task is already in progress'
         return undefined
       }
@@ -400,45 +410,45 @@ export class ExecutionService {
     })
     if (gate !== undefined) return { ok: false, error: gate }
 
-    // 1b. Worktree preparation (fail-soft): any failure degrades this run to
-    //     the original directory with an isolationNote — the ledger and the
-    //     execution pipeline itself never fail over git. 0.6.3: preparation
-    //     builds a whole-workspace MIRROR (root repo + nested repos); a plain
-    //     single-repo workspace keeps the legacy record shape everywhere.
     let isolationNote: string | undefined
     let prepared: PreparedMirror | undefined
-    if (isolation === 'worktree') {
-      if (this.deps.git === undefined) {
-        isolationNote = 'git 集成不可用，已在原目录执行'
-        await this.patchExecution(executionId, { isolation: 'none', isolationNote, branch: undefined, worktreePath: undefined, baseCommit: undefined })
-      } else {
-        const outcome = await prepareMirror(
-          { git: this.deps.git, scanner: this.deps.scanner ?? createRepoScanner() },
-          { workspacePath: workspace.path, taskId: task.id, branch, reuse: options?.reuseWorktree === true },
-        )
-        if ('mirror' in outcome) {
-          prepared = outcome.mirror
-          await this.pinBranches(task, prepared)
-          // Persist the isolation facts of the run (branch is already on the
-          // record from the gate mutation). The root repo keeps the legacy
-          // flat fields; non-legacy mirrors also record per-repo entries.
-          const root = prepared.repos[0]
-          await this.patchExecution(executionId, {
-            worktreePath: root?.worktreePath,
-            baseCommit: root?.baseCommit,
-            ...(!isLegacySingle(prepared)
-              ? { repos: prepared.repos.map(r => ({ repo: r.repo, branch: r.branch, worktreePath: r.worktreePath, baseCommit: r.baseCommit })) }
-              : {}),
-          })
-        } else {
-          isolationNote = outcome.note
-          // Degraded run: clear the optimistic worktree markers.
+
+    // Check reusable sessions before resetting any scheduled worktree.
+    const prepareIsolation = async (): Promise<void> => {
+      if (isolation === 'worktree') {
+        if (this.deps.git === undefined) {
+          isolationNote = 'git 集成不可用，已在原目录执行'
           await this.patchExecution(executionId, { isolation: 'none', isolationNote, branch: undefined, worktreePath: undefined, baseCommit: undefined })
+        } else {
+          const outcome = await prepareMirror(
+            { git: this.deps.git, scanner: this.deps.scanner ?? createRepoScanner() },
+            { workspacePath: workspace.path, taskId: task.id, branch, reuse: options?.reuseWorktree === true },
+          )
+          if ('mirror' in outcome) {
+            prepared = outcome.mirror
+            await this.pinBranches(task, prepared)
+            // Persist the isolation facts of the run (branch is already on the
+            // record from the gate mutation). The root repo keeps the legacy
+            // flat fields; non-legacy mirrors also record per-repo entries.
+            const root = prepared.repos[0]
+            await this.patchExecution(executionId, {
+              worktreePath: root?.worktreePath,
+              baseCommit: root?.baseCommit,
+              ...(!isLegacySingle(prepared)
+                ? { repos: prepared.repos.map(r => ({ repo: r.repo, branch: r.branch, worktreePath: r.worktreePath, baseCommit: r.baseCommit })) }
+                : {}),
+            })
+          } else {
+            isolationNote = outcome.note
+            // Degraded run: clear the optimistic worktree markers.
+            await this.patchExecution(executionId, { isolation: 'none', isolationNote, branch: undefined, worktreePath: undefined, baseCommit: undefined })
+          }
         }
       }
     }
+    if (trigger !== 'scheduled') await prepareIsolation()
 
-    // 2. Create the fresh agent+session inside the task's project, carrying
+    // 2. Create or resume the agent+session inside the task's project, carrying
     //    the pinned model — or the deployment default when unpinned (the
     //    persona template renders {{model}}, so the session always needs one).
     //    The session cwd is ALWAYS the project root: DSH's session model
@@ -463,9 +473,10 @@ export class ExecutionService {
       return { ok: false, error: `preset composition failed: ${message}` }
     }
     let handle: Awaited<ReturnType<AgentsFace['create']>>
+    let sessionReuseKey: string | undefined
     try {
       const model = task.model ?? this.deps.defaultModel?.()
-      handle = await this.deps.agents.create({
+      const createOptions: Parameters<AgentsFace['create']>[0] = {
         sessionId,
         meta: {
           cwd: workspace.path,
@@ -479,7 +490,22 @@ export class ExecutionService {
           },
         } : {}),
         ...(composition !== undefined ? { setup: composition.setup } : {}),
-      })
+      }
+      // Persist the effective settings, including resolved defaults. Never
+      // continue history under a different project, model, preset or boundary.
+      sessionReuseKey = JSON.stringify([
+        task.workspaceId, workspace.path, composition?.agentPreset ?? null,
+        model?.provider ?? null, model?.model ?? null, model?.reasoningEffort ?? null,
+        task.permission ?? DEFAULT_PERMISSION, isolation,
+      ])
+      const previous = trigger === 'scheduled'
+        ? [...task.executions].reverse().find(e => e.trigger === 'scheduled' && e.sessionId !== undefined)
+        : undefined
+      const resumed = previous?.sessionReuseKey === sessionReuseKey && previous.sessionId !== undefined
+        ? await this.deps.agents.resumeScheduled?.(previous.sessionId, createOptions)
+        : undefined
+      handle = resumed ?? await this.deps.agents.create(createOptions)
+      sessionId = handle.agent.id
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error)
       await this.patchExecution(executionId, { outcome: 'failed', error: message.slice(0, 500), endedAt: this.deps.now() })
@@ -489,6 +515,8 @@ export class ExecutionService {
       return { ok: false, error: message }
     }
 
+    if (trigger === 'scheduled') await prepareIsolation()
+
     // R3: the startup path above awaited seconds of git + agent work. A
     // cancel() that landed inside that window already settled the execution
     // (cancelled + task back to todo) — with nothing registered in `runs`,
@@ -499,7 +527,7 @@ export class ExecutionService {
     const stillRunning = await this.deps.store.read(ledger =>
       ledger.tasks.some(t => t.executions.some(e => e.id === executionId && e.outcome === 'running')))
     if (!stillRunning) {
-      await handle.dispose().catch(() => { /* best effort */ })
+      if (!handle.borrowed) await handle.dispose().catch(() => { /* best effort */ })
       // S1: do not leave the startup artifacts behind a cancelled run either.
       await this.cleanupMirror(prepared, workspace.path)
       return { ok: false, error: 'cancelled during startup' }
@@ -523,7 +551,26 @@ export class ExecutionService {
     } catch { /* cosmetic */ }
 
     // 4. Record the session id (execution is really started now).
-    await this.patchExecution(executionId, { sessionId })
+    await this.deps.store.mutate('execution-recorded', ledger => {
+      const target = ledger.tasks.find(t => t.id === taskId)
+      const execution = target?.executions.find(e => e.id === executionId && e.outcome === 'running')
+      if (target === undefined || execution === undefined) return undefined
+      Object.assign(execution, { sessionId, ...(trigger === 'scheduled' ? { sessionReuseKey } : {}) })
+      target.claimedBy = sessionId
+      return [target]
+    })
+
+    // Attach/ledger writes above may yield to manual activity or cancellation.
+    // Do not inject a scheduled prompt into an already running conversation.
+    const current = this.deps.store.get(taskId)?.executions.find(e => e.id === executionId)
+    if (current?.outcome !== 'running' || handle.agent.status === 'running') {
+      if (!handle.borrowed) await handle.dispose().catch(() => { /* best effort */ })
+      if (current?.outcome === 'running') {
+        await this.patchExecution(executionId, { outcome: 'failed', error: 'scheduled session is busy', endedAt: this.deps.now() })
+        await this.revertProgress(taskId)
+      }
+      return { ok: false, error: current?.outcome === 'running' ? 'scheduled session is busy' : 'cancelled during startup' }
+    }
 
     // 5. Submit the opening pair and settle on quiescence (turn/end errors
     //    were already folded by the listener). Two messages, ONE turn:
@@ -551,6 +598,7 @@ export class ExecutionService {
     //    when the session did NOT follow the handoff protocol — auto-move the
     //    card to in_review with a system comment.
     const settle = (): void => {
+      if (!this.runs.has(executionId)) return
       this.runs.delete(executionId)
       void this.settleExecution(executionId, sessionId, prepared)
     }
@@ -562,7 +610,7 @@ export class ExecutionService {
     // succeeded (and auto-moved to in_review). Now only the failure
     // settlement writes, and the run entry is released after it commits.
     void handle.agent.whenIdle().then(settle, () => {
-      this.noteFailure(sessionId, 'agent did not reach quiescence')
+      this.noteFailure(sessionId, 'agent did not reach quiescence', executionId)
         .then(() => { this.runs.delete(executionId) })
         .catch(() => { this.runs.delete(executionId) })
     })
@@ -594,7 +642,7 @@ export class ExecutionService {
             delete t.claimedAt
           }
           if (t.status === 'in_progress') {
-            const commented = t.comments.some(c => c.threadId === sessionId)
+            const commented = t.comments.some(c => c.threadId === sessionId && c.createdAt >= (execution.startedAt ?? 0))
             t.comments.push({
               id: newCommentId(),
               body: normalizeBody(commented
@@ -861,4 +909,4 @@ export class ExecutionService {
       return undefined
     })
   }
-}
+}

package/src/host/scheduled-session.ts

@@ -0,0 +1,68 @@
+/** Adapt DSH's live-agent and durable-session APIs for recurring executions. */
+import type { AgentsFace } from './execution.ts'
+
+type CreateOptions = Parameters<AgentsFace['create']>[0]
+type Handle = Awaited<ReturnType<AgentsFace['create']>>
+type Header = { cwd?: string; agentPreset?: string }
+
+export interface ScheduledSessionDeps {
+  agents: {
+    get(id: string): (Handle['agent'] & {
+      session: { header: Header }
+      options: CreateOptions['agentOptions']
+      cancel(cause: { kind: 'user' }): void
+    }) | undefined
+    resume(options: { resumeSessionId: string; agentOptions?: CreateOptions['agentOptions']; setup?: CreateOptions['setup'] }): Promise<Handle>
+  }
+  persistence(): { stat(id: string): Promise<{ header: Header } | undefined> } | undefined
+  isArchived(id: string): boolean
+}
+
+/**
+ * Only confirmed absence, archival or incompatible configuration permits a
+ * replacement session... and so does any resume obstacle: busy, locked or
+ * corrupt sessions degrade to a brand-new conversation (issue #26 policy),
+ * trading history continuity for guaranteed execution progress.
+ */
+export function scheduledSessionResumer(deps: ScheduledSessionDeps): NonNullable<AgentsFace['resumeScheduled']> {
+  return async (sessionId, options) => {
+    if (deps.isArchived(sessionId)) return undefined
+    const compatible = (header: Header): boolean => header.cwd === options.meta?.cwd
+      && header.agentPreset === options.meta?.agentPreset
+    const live = deps.agents.get(sessionId)
+    if (live !== undefined) {
+      // Busy: never queue behind the running conversation — fall back to a
+      // fresh session so the scheduled trigger still makes progress.
+      if (live.status !== 'idle') return undefined
+      if (!compatible(live.session.header)) return undefined
+      const model = options.agentOptions
+      if (live.options?.provider !== model?.provider || live.options?.model !== model?.model
+        || live.options?.reasoningEffort !== model?.reasoningEffort) return undefined
+      return {
+        agent: live,
+        borrowed: true,
+        // A registry lookup grants no ownership. Cancel this activity without
+        // disposing the agent owned by another service (for example the UI).
+        dispose: async () => { live.cancel({ kind: 'user' }); await live.whenIdle() },
+      }
+    }
+    // Unreadable metadata (locked/corrupt/disk trouble) degrades to a fresh
+    // session rather than failing the whole scheduled run.
+    let stored: { header: Header } | undefined
+    try {
+      const persistence = deps.persistence()
+      stored = await persistence?.stat(sessionId)
+    } catch { return undefined }
+    if (stored === undefined || !compatible(stored.header)) return undefined
+    // Recheck after the asynchronous metadata read, including a GUI resume.
+    if (deps.isArchived(sessionId)) return undefined
+    if (deps.agents.get(sessionId) !== undefined) return undefined
+    try {
+      return await deps.agents.resume({
+        resumeSessionId: sessionId,
+        ...(options.agentOptions !== undefined ? { agentOptions: options.agentOptions } : {}),
+        ...(options.setup !== undefined ? { setup: options.setup } : {}),
+      })
+    } catch { return undefined }
+  }
+}

package/src/index.ts

@@ -21,6 +21,7 @@ import type {} from '@deepseek-ai/dsh-system-prompt'
 import type {} from '@deepseek-ai/dsh-agent'
 import { PROTOCOL_SECTION_NAME, PROTOCOL_SECTION_ORDER, TASKBOARD_PROTOCOL } from './host/protocol-text.ts'
 import { DEFAULT_MAX_CONCURRENT, ExecutionService, type EventsFace } from './host/execution.ts'
+import { scheduledSessionResumer, type ScheduledSessionDeps } from './host/scheduled-session.ts'
 import { createGitFace } from './host/git.ts'
 import { createRepoScanner } from './host/repos.ts'
 import { registerTaskboardRoutes } from './host/routes.ts'
@@ -183,6 +184,14 @@ export function apply(ctx: Context): void {
         store,
         agents: {
           create: (options): Promise<never> => agentCtx.agents.create(options as never) as Promise<never>,
+          resumeScheduled: scheduledSessionResumer({
+            agents: {
+              get: id => agentCtx.agents.get(id as never) as unknown as ReturnType<ScheduledSessionDeps['agents']['get']>,
+              resume: options => agentCtx.agents.resume(options as never) as Promise<never>,
+            },
+            persistence: () => agentCtx.get('sessionPersistence') as ReturnType<ScheduledSessionDeps['persistence']>,
+            isArchived: id => wsCtx.workspaceRegistry.archivedSessionIds.includes(id as never),
+          }),
         },
         workspaces: {
           get: id => workspaceFace(wsCtx.workspaceRegistry).get(id),

package/src/shared/protocol.ts

@@ -461,6 +461,8 @@ export type ExecutionRecord = {
   id: string
   /** The session this execution ran in; set once the session is really started. */
   sessionId?: string
+  /** Effective configuration of a scheduled session; used only for compatible reuse. */
+  sessionReuseKey?: string
   /** Trigger: manual button or the host scheduler. */
   trigger: 'manual' | 'scheduled'
   startedAt?: number