dsh-taskboard 0.1.1 → 0.2.0

package/src/client/sidebar-entry.ts

@@ -59,11 +59,106 @@ function createEntry(controller: BoardController): HTMLButtonElement {
   entry.dataset.dshAtbEntry = ''
   entry.className = 'dsh-atb-entry'
   entry.setAttribute('aria-label', 'Agent 任务看板')
-  entry.innerHTML = `<span class="dsh-atb-entry-icon">${ICON}</span><span class="dsh-atb-entry-label">任务看板</span>`
+  entry.innerHTML = `<span class="dsh-atb-entry-icon">${ICON}</span><span class="dsh-atb-entry-label">任务看板</span><span class="dsh-atb-entry-stats"></span>`
   entry.addEventListener('click', () => { controller.toggleBoard() })
   return entry
 }
 
+/**
+ * Live status counts shown at the right of the entry row:
+ * `[todo, in_progress, in_review]` (trashed tasks excluded).
+ */
+function entryStats(controller: BoardController): [number, number, number] {
+  let todo = 0
+  let inProgress = 0
+  let inReview = 0
+  for (const task of controller.getSnapshot().ledger.tasks) {
+    if (task.trashedAt !== undefined) continue
+    if (task.status === 'todo') todo++
+    else if (task.status === 'in_progress') inProgress++
+    else if (task.status === 'in_review') inReview++
+  }
+  return [todo, inProgress, inReview]
+}
+
+/**
+ * Set one rolling-number slot. Unchanged values no-op; changes animate the
+ * old value out and the new value in with a vertical scroll (up when the
+ * count grows, down when it shrinks). Plain DOM, no React.
+ */
+function setRollValue(slot: HTMLElement, value: number): void {
+  const text = String(value)
+  if (slot.dataset.value === text) return
+  const previous = slot.dataset.value
+  slot.dataset.value = text
+  slot.style.minWidth = `${text.length}ch`
+  // First render (no previous value): plain text, no animation.
+  if (previous === undefined) {
+    slot.textContent = text
+    return
+  }
+  // Finalize any in-flight animation before starting the next one.
+  if (slot.dataset.busy === '1') {
+    slot.dataset.busy = ''
+    slot.dataset.anim = ''
+  }
+  const oldEl = document.createElement('span')
+  oldEl.className = 'dsh-atb-rn'
+  oldEl.textContent = previous
+  const newEl = document.createElement('span')
+  newEl.className = 'dsh-atb-rn dsh-atb-rn-next'
+  newEl.textContent = text
+  slot.replaceChildren(oldEl, newEl)
+  // Grow → the strip scrolls up (new enters from below); shrink → down.
+  slot.dataset.dir = value > Number(previous) ? 'up' : 'down'
+  slot.dataset.busy = '1'
+  requestAnimationFrame(() => { slot.dataset.anim = '1' })
+  const finish = (): void => {
+    if (slot.dataset.busy !== '1') return
+    slot.dataset.busy = ''
+    slot.dataset.anim = ''
+    slot.textContent = slot.dataset.value ?? ''
+  }
+  slot.addEventListener('transitionend', finish, { once: true })
+  // Fallback when transitionend never fires (hidden tab, reduced motion).
+  setTimeout(finish, 400)
+}
+
+/**
+ * Wire the stats strip into the entry: builds the three slots and keeps them
+ * (plus the tooltip) in sync with every controller emit.
+ * @returns the update function (also called once immediately).
+ */
+function wireStats(entry: HTMLButtonElement, controller: BoardController): () => void {
+  const stats = entry.querySelector<HTMLElement>('.dsh-atb-entry-stats')
+  if (stats === null) return () => {}
+  // Slot order = [todo, in_progress, in_review]; each slot carries its status
+  // in data-stat so the stylesheet colors the digits (see .dsh-atb-roll).
+  const statKeys = ['todo', 'in_progress', 'in_review'] as const
+  const slots: HTMLElement[] = []
+  for (let i = 0; i < 3; i++) {
+    if (i > 0) {
+      const sep = document.createElement('span')
+      sep.className = 'dsh-atb-entry-sep'
+      sep.textContent = '|'
+      stats.append(sep)
+    }
+    const slot = document.createElement('span')
+    slot.className = 'dsh-atb-roll'
+    slot.dataset.stat = statKeys[i]
+    stats.append(slot)
+    slots.push(slot)
+  }
+  const update = (): void => {
+    const [todo, inProgress, inReview] = entryStats(controller)
+    setRollValue(slots[0]!, todo)
+    setRollValue(slots[1]!, inProgress)
+    setRollValue(slots[2]!, inReview)
+    stats.title = `待办 ${todo} ｜ 进行中 ${inProgress} ｜ 待验收 ${inReview}（待办|进行中|待验收）`
+  }
+  return update
+}
+
 /** Re-insert the entry after the New Session row (before the browser region). */
 function placeEntry(root: HTMLElement, entry: HTMLButtonElement): boolean {
   const button = newSessionButton(root)
@@ -146,9 +241,11 @@ export function mountSidebarEntry(controller: BoardController): () => void {
   // alone; the timer costs one cheap contains-check per tick once placed).
   const retry = setInterval(() => { tryPlace() }, 2_000)
 
+  const syncStats = wireStats(entry, controller)
   const syncActive = () => {
     if (controller.getSnapshot().boardOpen) entry.dataset.active = 'true'
     else delete entry.dataset.active
+    syncStats()
   }
   const unsubscribe = controller.subscribe(syncActive)
   syncActive()

package/src/client/styles.ts

@@ -10,7 +10,7 @@
 /** The stylesheet text. */
 export const STYLES = `
 .dsh-atb-entry {
-  display: flex; align-items: center; gap: 8px;
+  display: flex; align-items: center; gap: 8px; position: relative;
   width: calc(100% - 8px); margin: 2px 4px; padding: 6px 10px;
   border: none; border-radius: 8px; background: transparent;
   color: var(--dsw-text-secondary, inherit); font: inherit; font-size: 13px;
@@ -19,6 +19,35 @@ export const STYLES = `
 .dsh-atb-entry:hover { background: var(--dsw-hover, rgba(128,128,128,.12)); color: var(--dsw-text-primary, inherit); }
 .dsh-atb-entry[data-active="true"] { background: var(--dsw-active, rgba(128,128,128,.18)); color: var(--dsw-text-primary, inherit); font-weight: 500; }
 .dsh-atb-entry svg { flex: none; }
+/* Status strip on the entry row's right: todo|in_progress|in_review counts. */
+.dsh-atb-entry-stats {
+  margin-left: auto; display: inline-flex; align-items: center; gap: 3px;
+  font-size: 11px; line-height: 1; color: var(--dsw-text-secondary, gray);
+  font-variant-numeric: tabular-nums; white-space: nowrap; cursor: help;
+}
+.dsh-atb-entry-sep { opacity: .5; }
+/* Each rolling count wears its status color (todo blue | in_progress orange |
+   in_review purple); the separators stay in the strip's neutral gray. */
+.dsh-atb-roll[data-stat="todo"] { color: #3e63dd; }
+.dsh-atb-roll[data-stat="in_progress"] { color: #d9822b; }
+.dsh-atb-roll[data-stat="in_review"] { color: #8e4ec6; }
+/* One rolling number: fixed one-line window, overflow hidden. */
+.dsh-atb-roll {
+  position: relative; display: inline-block; overflow: hidden;
+  height: 12px; min-width: 1ch; text-align: center; vertical-align: middle;
+}
+.dsh-atb-rn { display: block; height: 12px; line-height: 12px; text-align: center; }
+/* The incoming value sits just outside the window (below for up-scroll). */
+.dsh-atb-rn-next { position: absolute; left: 0; right: 0; top: 100%; }
+.dsh-atb-roll[data-dir="down"] .dsh-atb-rn-next { top: auto; bottom: 100%; }
+.dsh-atb-roll .dsh-atb-rn { transition: transform .3s cubic-bezier(.25, .1, .25, 1); }
+.dsh-atb-roll[data-anim="1"][data-dir="up"] .dsh-atb-rn { transform: translateY(-100%); }
+.dsh-atb-roll[data-anim="1"][data-dir="down"] .dsh-atb-rn { transform: translateY(100%); }
+@media (prefers-reduced-motion: reduce) {
+  .dsh-atb-roll .dsh-atb-rn { transition: none; }
+}
+.dsh-atb-search { width: 130px; }
+.dsh-atb-badge[data-kind="stale"] { background: rgba(217,130,43,.15); color: #d9822b; }
 
 html[data-dsh-atb-active] [data-pane="conversation"] > *:not([data-dsh-atb-view]) { display: none !important; }
 .dsh-atb-view { display: none; }
@@ -28,6 +57,16 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
 .dsh-atb-toolbar { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
 .dsh-atb-title { font-size: 15px; font-weight: 600; margin: 0; }
 .dsh-atb-count { font-size: 12px; color: var(--dsw-text-secondary, gray); }
+.dsh-atb-ver {
+  font-size: 11px; color: var(--dsw-text-secondary, gray);
+  font-variant-numeric: tabular-nums; white-space: nowrap; cursor: pointer;
+  text-decoration: none;
+  padding: 1px 9px; border-radius: 999px;
+  background: var(--dsw-bg-inset, rgba(128,128,128,.1));
+  border: 1px solid var(--dsw-border, rgba(128,128,128,.22));
+  transition: border-color .12s ease, color .12s ease;
+}
+.dsh-atb-ver:hover { border-color: var(--dsw-border-strong, rgba(128,128,128,.6)); color: inherit; }
 .dsh-atb-spacer { flex: 1; }
 .dsh-atb-select, .dsh-atb-input {
   font: inherit; font-size: 12.5px; padding: 5px 8px; border-radius: 7px;
@@ -48,6 +87,16 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
 .dsh-atb-dot[data-urgency="urgent"] { background: #e5484d; }
 .dsh-atb-dot[data-urgency="normal"] { background: #8e4ec6; }
 .dsh-atb-dot[data-urgency="relaxed"] { background: #3e63dd; }
+/* Status dots (column heads): one fixed color per lifecycle status, matching
+   the detail pane's status pills. Canceled/archived share the resting gray;
+   trashed (pending purge) keeps the red of the 待清除 badge. */
+.dsh-atb-dot[data-status="backlog"] { background: #8a8f98; }
+.dsh-atb-dot[data-status="todo"] { background: #3e63dd; }
+.dsh-atb-dot[data-status="in_progress"] { background: #d9822b; }
+.dsh-atb-dot[data-status="in_review"] { background: #8e4ec6; }
+.dsh-atb-dot[data-status="done"] { background: #2ea043; }
+.dsh-atb-dot[data-status="canceled"], .dsh-atb-dot[data-status="archived"] { background: #8a8f98; }
+.dsh-atb-dot[data-status="trashed"] { background: #e5484d; }
 
 .dsh-atb-btn {
   font: inherit; font-size: 12.5px; padding: 5px 11px; border-radius: 7px; cursor: pointer;
@@ -172,12 +221,13 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
 .dsh-atb-desc { white-space: pre-wrap; word-break: break-word; font-size: 13px; line-height: 1.55; }
 
 .dsh-atb-detail-actions { display: flex; flex-direction: column; gap: 8px; }
-.dsh-atb-runbtn {
-  font: inherit; font-size: 13px; font-weight: 600; padding: 8px 14px; border-radius: 9px; cursor: pointer;
-  border: 1px solid transparent; background: var(--dsw-alias-button-primary-fill, var(--dsw-alias-brand-primary, #1f2328)); color: var(--dsw-alias-label-primary-foreground, #fff); text-align: center;
+.dsh-atb-detail-run {
+  font: inherit; font-size: 12px; font-weight: 600; padding: 4px 11px; border-radius: 7px; cursor: pointer;
+  border: 1px solid transparent; background: var(--dsw-alias-button-primary-fill, var(--dsw-alias-brand-primary, #1f2328)); color: var(--dsw-alias-label-primary-foreground, #fff);
   transition: filter .12s ease;
 }
-.dsh-atb-runbtn:hover { filter: brightness(1.1); }
+.dsh-atb-detail-run:hover { filter: brightness(1.1); }
+.dsh-atb-detail-run[data-danger="true"] { background: rgba(229,72,77,.92); }
 .dsh-atb-movebtns { display: flex; gap: 6px; flex-wrap: wrap; }
 .dsh-atb-movebtn {
   font: inherit; font-size: 12px; padding: 4px 11px; border-radius: 999px; cursor: pointer;
@@ -256,7 +306,11 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
 .dsh-atb-exec-outcome[data-outcome="running"] { background: rgba(217,130,43,.15); color: #d9822b; }
 .dsh-atb-exec-outcome[data-outcome="cancelled"] { background: rgba(128,128,128,.15); color: var(--dsw-text-secondary, gray); }
 .dsh-atb-exec-time { font-size: 11px; color: var(--dsw-text-secondary, gray); }
-.dsh-atb-exec-session { font-size: 11px; color: var(--dsw-text-secondary, gray); }
+.dsh-atb-exec-session {
+  font: inherit; font-size: 11px; color: var(--dsw-text-secondary, gray);
+  background: none; border: none; padding: 0; cursor: pointer;
+}
+.dsh-atb-exec-session:hover { color: var(--dsw-alias-brand-primary, inherit); text-decoration: underline dotted; }
 .dsh-atb-exec-error { flex-basis: 100%; font-size: 11px; color: #e5484d; word-break: break-all; }
 
 .dsh-atb-dangerzone {
@@ -376,6 +430,29 @@ html[data-dsh-atb-active] .dsh-atb-view { display: flex; flex-direction: column;
 .dsh-atb-secondary { flex: 1; min-height: 0; overflow-y: auto; display: flex; flex-direction: column; gap: 8px; }
 .dsh-atb-link { color: var(--dsw-alias-state-business-primary, #3e63dd); cursor: pointer; text-decoration: none; }
 .dsh-atb-link:hover { text-decoration: underline; }
+
+/* ---------- alert modal ---------- */
+.dsh-atb-alert-backdrop {
+  position: fixed; inset: 0; z-index: 90;
+  background: var(--dsw-alias-bg-mask-drop, rgba(28,30,36,.4)); backdrop-filter: var(--dsw-mask-blur, blur(2px));
+  display: flex; align-items: center; justify-content: center;
+  animation: dsh-atb-fade .12s ease;
+}
+.dsh-atb-alert {
+  min-width: 280px; max-width: 380px; padding: 20px 24px; border-radius: 14px;
+  background: var(--dsw-alias-bg-overlay, #fff); color: var(--dsw-alias-label-primary, inherit);
+  border: 1px solid var(--dsw-alias-border-l2, rgba(128,128,128,.25));
+  box-shadow: var(--dsw-shadow-lv3, 0 12px 32px rgba(0,0,0,.18));
+  display: flex; flex-direction: column; align-items: center; gap: 14px;
+  animation: dsh-atb-pop .14s ease;
+}
+.dsh-atb-alert-icon { font-size: 28px; line-height: 1; }
+.dsh-atb-alert-msg {
+  font-size: 13.5px; line-height: 1.55; text-align: center;
+  word-break: break-word; white-space: pre-wrap;
+  color: var(--dsw-alias-label-primary, inherit);
+}
+.dsh-atb-alert .dsh-atb-btn { padding: 6px 28px; font-size: 13px; }
 `
 
 let injected = false

package/src/host/execution.ts

@@ -10,10 +10,20 @@
  *
  * @module dsh-taskboard/host/execution
  */
-import { effectivePrompt, newExecutionId, type ExecutionRecord, type TaskRecord } from '../shared/protocol.ts'
+import {
+  effectivePrompt,
+  newCommentId,
+  newExecutionId,
+  normalizeBody,
+  type ExecutionRecord,
+  type TaskRecord,
+} from '../shared/protocol.ts'
 import { MessageId } from './sdk.ts'
 import type { TaskStore } from './store.ts'
 
+/** Default cap on concurrently running executions (env-overridable). */
+export const DEFAULT_MAX_CONCURRENT = 3
+
 /** Narrow agents face (the registry's create, structurally). */
 export interface AgentsFace {
   create(options: {
@@ -54,6 +64,10 @@ export interface ExecutionDeps {
   mintSessionId?: () => string
   /** Mint message ids (injectable for tests). */
   mintMessageId?: () => string
+  /** Best-effort session rename (pins the session list title to the task title). */
+  renameSession?: (sessionId: string, title: string) => void
+  /** Max concurrently running executions across all tasks (default 3). */
+  maxConcurrent?: number
 }
 
 /** Outcome of a run request (immediate; the run settles asynchronously). */
@@ -61,6 +75,11 @@ export type RunRequestResult =
   | { ok: true; executionId: string; sessionId: string }
   | { ok: false; error: string }
 
+/** Outcome of a cancel request. */
+export type CancelRequestResult =
+  | { ok: true; executionId: string }
+  | { ok: false; error: string }
+
 /** Whether a turn/end payload closed with an error reason. */
 function isErrorTurnEnd(data: unknown): { message: string } | undefined {
   if (typeof data !== 'object' || data === null) return undefined
@@ -76,12 +95,19 @@ function isErrorTurnEnd(data: unknown): { message: string } | undefined {
   return { message }
 }
 
+/** One live execution tracked for settlement and cancellation. */
+interface RunEntry {
+  sessionId: string
+  settle: () => void
+  dispose: () => Promise<void>
+}
+
 /**
  * The execution service.
  */
 export class ExecutionService {
-  /** Execution ids currently settling. */
-  private readonly settling = new Map<string, () => void>()
+  /** Live executions by execution id (settles and cancels remove entries). */
+  private readonly runs = new Map<string, RunEntry>()
 
   /** @param deps - store + agents + workspaces + events + clock. */
   constructor(private readonly deps: ExecutionDeps) {
@@ -92,7 +118,7 @@ export class ExecutionService {
     })
   }
 
-  /** Record a turn failure against the running execution of that session. */
+  /** Record a turn failure against the running execution of that session and give the task back. */
   private noteFailure(sessionId: string, message: string): void {
     void this.deps.store.mutate('execution-recorded', (ledger) => {
       for (const task of ledger.tasks) {
@@ -101,6 +127,21 @@ export class ExecutionService {
             execution.outcome = 'failed'
             execution.error = message.slice(0, 500)
             execution.endedAt = this.deps.now()
+            // The failed session will not finish the work: hand the task back
+            // instead of leaving it stuck in in_progress forever — and leave a
+            // system comment so the GUI shows why.
+            if (task.status === 'in_progress' && task.claimedBy === sessionId) {
+              task.status = 'todo'
+              task.updatedAt = this.deps.now()
+              delete task.claimedBy
+              delete task.claimedAt
+              task.comments.push({
+                id: newCommentId(),
+                body: normalizeBody(`[系统] 执行失败：${message.slice(0, 300)}；任务已退回待办。`),
+                version: 1,
+                createdAt: this.deps.now(),
+              })
+            }
             return [task]
           }
         }
@@ -125,18 +166,24 @@ export class ExecutionService {
 
   /**
    * Run one task now (manual button or scheduler tick).
+   *
+   * The in-progress gate and the execution-open write happen inside ONE
+   * serial-queue mutation, so two overlapping run() calls (double click,
+   * overlapping scheduler ticks) can never both pass — exactly one session
+   * is opened per task.
    * @param taskId - the task to run.
    * @param trigger - what started it.
    * @returns the immediate result; settlement lands in the ledger.
    */
   async run(taskId: string, trigger: ExecutionRecord['trigger']): Promise<RunRequestResult> {
+    const max = this.deps.maxConcurrent ?? DEFAULT_MAX_CONCURRENT
+    if (this.runs.size >= max) {
+      return { ok: false, error: `execution concurrency limit reached (${this.runs.size}/${max} running)` }
+    }
     const task = this.deps.store.get(taskId)
     if (task === undefined || task.trashedAt !== undefined) {
       return { ok: false, error: `no task ${taskId}` }
     }
-    if (task.status === 'in_progress') {
-      return { ok: false, error: 'task is already in progress' }
-    }
     const workspace = this.deps.workspaces.get(task.workspaceId)
     if (workspace === undefined) {
       return { ok: false, error: `unknown workspace ${task.workspaceId}` }
@@ -145,10 +192,19 @@ export class ExecutionService {
     const executionId = newExecutionId()
     const sessionId = this.deps.mintSessionId?.() ?? `session-taskboard-${crypto.randomUUID()}`
 
-    // 1. Open the execution record and move the card to in_progress in one write.
+    // 1. Open the execution record, flip the card to in_progress, and record
+    //    the executing session as the claim holder — atomically.
+    let gate: string | undefined
     await this.deps.store.mutate('execution-recorded', (ledger) => {
       const target = ledger.tasks.find(t => t.id === taskId)
-      if (target === undefined) return undefined
+      if (target === undefined || target.trashedAt !== undefined) {
+        gate = `no task ${taskId}`
+        return undefined
+      }
+      if (target.status === 'in_progress') {
+        gate = 'task is already in progress'
+        return undefined
+      }
       target.executions.push({
         id: executionId,
         trigger,
@@ -158,8 +214,11 @@ export class ExecutionService {
       target.status = 'in_progress'
       target.updatedAt = this.deps.now()
       target.updatedBy = { kind: 'user' }
+      target.claimedBy = sessionId
+      target.claimedAt = this.deps.now()
       return [target]
     })
+    if (gate !== undefined) return { ok: false, error: gate }
 
     // 2. Create the fresh agent+session inside the task's project, carrying
     //    the pinned model — or the deployment default when unpinned (the
@@ -182,35 +241,66 @@ export class ExecutionService {
     // 3. Attach the session to the workspace (GUI project session list).
     await this.deps.workspaces.attach(task.workspaceId, sessionId).catch(() => { /* cosmetic */ })
 
+    // 3b. Best-effort rename: pin the session title to the task title so the
+    //     session list shows the task name (a user-sourced title also stops
+    //     automatic first-prompt retitling).
+    try {
+      this.deps.renameSession?.(sessionId, task.title)
+    } catch { /* cosmetic */ }
+
     // 4. Record the session id (execution is really started now).
     await this.patchExecution(executionId, { sessionId })
 
     // 5. Submit the effective prompt as an ordinary user message and settle
     //    on quiescence (turn/end errors were already folded by the listener).
+    //    Source `user` (not `plugin`) so the opening message renders as a
+    //    normal user bubble in the conversation, exactly like a typed prompt.
     const message = {
       id: this.deps.mintMessageId?.() ?? MessageId(`msg-taskboard-${crypto.randomUUID()}`),
       role: 'user' as const,
       content: [{ type: 'text' as const, text: this.executionPrompt(task) }],
-      source: { kind: 'plugin' as const, plugin: 'dsh-taskboard' },
+      source: { kind: 'user' as const },
     }
     handle.agent.followup(message)
 
-    // 6. Settlement watcher.
+    // 6. Settlement watcher: mark succeeded, release the executing session's
+    //    hold, and — when the session did NOT follow the handoff protocol —
+    //    auto-move the card to in_review with a system comment (otherwise a
+    //    disobedient session would leave it hanging in in_progress forever).
     const settle = (): void => {
-      this.settling.delete(executionId)
+      this.runs.delete(executionId)
       void this.deps.store.mutate('execution-recorded', (ledger) => {
         for (const t of ledger.tasks) {
           const execution = t.executions.find(e => e.id === executionId)
           if (execution !== undefined && execution.outcome === 'running') {
+            const now = this.deps.now()
             execution.outcome = 'succeeded'
-            execution.endedAt = this.deps.now()
+            execution.endedAt = now
+            if (t.status === 'in_progress' && t.claimedBy === sessionId) {
+              delete t.claimedBy
+              delete t.claimedAt
+            }
+            if (t.status === 'in_progress') {
+              const commented = t.comments.some(c => c.threadId === sessionId)
+              t.comments.push({
+                id: newCommentId(),
+                body: normalizeBody(commented
+                  ? '[系统] 执行会话已结束并留有评论，但未移至待验收；系统自动移入待验收。'
+                  : '[系统] 执行会话已结束，但未按协议交接（无评论、未移至待验收）；系统自动移入待验收，请审查后退回或验收。'),
+                version: 1,
+                createdAt: now,
+              })
+              t.status = 'in_review'
+              t.updatedAt = now
+              t.updatedBy = { kind: 'user' }
+            }
             return [t]
           }
         }
         return undefined
       })
     }
-    this.settling.set(executionId, settle)
+    this.runs.set(executionId, { sessionId, settle, dispose: () => handle.dispose() })
     void handle.agent.whenIdle().then(settle, () => {
       this.noteFailure(sessionId, 'agent did not reach quiescence')
       settle()
@@ -219,23 +309,117 @@ export class ExecutionService {
     return { ok: true, executionId, sessionId }
   }
 
-  /** The prompt text one execution submits (task context + instructions). */
+  /** How many executions are currently running (for the concurrency cap). */
+  inFlight(): number {
+    return this.runs.size
+  }
+
+  /**
+   * Cancel the running execution of a task (user action): stop the agent
+   * session, mark the execution cancelled, and hand the task back to todo.
+   * @param taskId - the task whose execution should be stopped.
+   * @returns the immediate result.
+   */
+  async cancel(taskId: string): Promise<CancelRequestResult> {
+    const task = this.deps.store.get(taskId)
+    if (task === undefined) return { ok: false, error: `no task ${taskId}` }
+    const running = [...task.executions].reverse().find(e => e.outcome === 'running')
+    if (running === undefined) return { ok: false, error: 'no running execution' }
+
+    const entry = this.runs.get(running.id)
+    this.runs.delete(running.id)
+    // Stop the agent first (best effort): dispose stops the loop, unregisters
+    // the agent, and removes its session. A late whenIdle settlement no-ops —
+    // the record is no longer 'running'.
+    try {
+      await entry?.dispose()
+    } catch { /* already gone */ }
+
+    await this.deps.store.mutate('execution-recorded', (ledger) => {
+      const target = ledger.tasks.find(t => t.id === taskId)
+      if (target === undefined) return undefined
+      const execution = target.executions.find(e => e.id === running.id)
+      if (execution === undefined || execution.outcome !== 'running') return undefined
+      execution.outcome = 'cancelled'
+      execution.endedAt = this.deps.now()
+      if (target.status === 'in_progress') {
+        target.status = 'todo'
+        target.updatedAt = this.deps.now()
+        delete target.claimedBy
+        delete target.claimedAt
+      }
+      return [target]
+    })
+    return { ok: true, executionId: running.id }
+  }
+
+  /**
+   * Startup reconciliation after a host restart: executions left `running`
+   * by the previous process can never settle here (their settlement watchers
+   * died with it), so mark them failed and hand their tasks back to todo.
+   */
+  async reconcile(): Promise<void> {
+    await this.deps.store.mutate('execution-recorded', (ledger) => {
+      const now = this.deps.now()
+      const touched: TaskRecord[] = []
+      for (const task of ledger.tasks) {
+        let dirty = false
+        for (const execution of task.executions) {
+          if (execution.outcome === 'running') {
+            execution.outcome = 'failed'
+            execution.error = 'interrupted by host restart'
+            execution.endedAt = now
+            dirty = true
+          }
+        }
+        if (!dirty) continue
+        if (task.status === 'in_progress') {
+          task.status = 'todo'
+          task.updatedAt = now
+          delete task.claimedBy
+          delete task.claimedAt
+        }
+        touched.push(task)
+      }
+      return touched.length > 0 ? touched : undefined
+    })
+  }
+
+  /**
+   * The prompt text one execution submits (task context + instructions).
+   * The effective prompt supports two template variables, rendered from the
+   * task's own history at submit time (valuable for recurring patrols):
+   * `{{lastExecution}}` → the previous execution's trigger/outcome/error;
+   * `{{lastComments}}` → the last three comments (who + body).
+   */
   private executionPrompt(task: TaskRecord): string {
-    const head = `【任务看板执行】${task.title}（任务 ID: ${task.id}）`
     const state = '本任务由执行服务启动本会话并已置为 in_progress（你无需再认领，也无需移到 done）。'
     const tail = `完成后请：1) 用 taskboard_get 读取任务 ${task.id} 拿最新 version；`
       + `2) 用 taskboard_comment_add 留评论（做了什么改动、如何验证、剩余风险）；`
       + `3) 用 taskboard_move 把任务 ${task.id} 移到 in_review（带 ifVersion）。`
-    return `${head}\n\n${state}\n\n${effectivePrompt(task)}\n\n${tail}`
+    const base = effectivePrompt(task)
+    const lastExec = [...task.executions].reverse().find(e => e.outcome !== 'running')
+    const lastExecText = lastExec === undefined
+      ? '（无）'
+      : `${lastExec.trigger} · ${lastExec.outcome}${lastExec.error !== undefined ? ` · ${lastExec.error.slice(0, 200)}` : ''} · ${new Date(lastExec.startedAt ?? 0).toISOString()}`
+    const lastCommentsText = task.comments.slice(-3)
+      .map(c => `[${c.threadId !== undefined ? 'agent' : 'user'}] ${c.body}`)
+      .join('\n') || '（无）'
+    const body = base
+      .replace(/\{\{lastExecution\}\}/g, lastExecText)
+      .replace(/\{\{lastComments\}\}/g, lastCommentsText)
+    return `【任务】${task.title}（任务 ID: ${task.id}）\n\n${state}\n\n${body}\n\n${tail}`
   }
 
-  /** Move a task back out of in_progress after a failed start. */
+  /** Move a task back out of in_progress (and release its hold) after a failed start. */
   private async revertProgress(taskId: string): Promise<void> {
     await this.deps.store.mutate('execution-recorded', (ledger) => {
       const target = ledger.tasks.find(t => t.id === taskId)
       if (target !== undefined && target.status === 'in_progress') {
         target.status = 'todo'
         target.updatedAt = this.deps.now()
+        delete target.claimedBy
+        delete target.claimedAt
         return [target]
       }
       return undefined