@goodandready/dsh-kanban 0.2.34 → 0.2.36

package/lib/server/timers.js

@@ -0,0 +1,204 @@
+import { computeNextRun } from '../cron.js'
+import { PERMISSION_RANKS, resolveModel, runTask } from '../launcher.js'
+import { createOutbox, planOutbound } from '../outbound.js'
+import { createSyncState, syncAll, intakeAll, archiveOverdue } from '../sync.js'
+import { SessionId } from '@deepseek-ai/dsh-session'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import { randomUUID } from 'node:crypto'
+
+export function registerKanbanTimers(ctx, deps) {
+  const {
+    store,
+    getConfig,
+    eventHub,
+    syncPower,
+    git,
+    gitea,
+    github,
+    rearmers,
+    watchdog,
+  } = deps
+
+  ctx.effect(() => {
+    let cronTimer
+    const armCron = () => {
+      clearInterval(cronTimer)
+      cronTimer = undefined
+      if (getConfig().cronEnabled !== true) return
+      cronTimer = setInterval(async () => {
+        try {
+          if (!store) return
+          const now = Date.now()
+          const dueTasks = store.listDueTasks(now)
+          for (const task of dueTasks) {
+            if (task.column === 'in-progress') {
+              const next = computeNextRun(task.cron, now)
+              store.updateTask(task.id, { lastRunAt: now, nextRunAt: next || 0 })
+              continue
+            }
+            if (getConfig().permissionGateEnabled) {
+              const perm = task.permission || 'read-only'
+              const defaultPerm = getConfig().sessionDefaultPermission || 'read-only'
+              if ((PERMISSION_RANKS[perm] ?? 0) > (PERMISSION_RANKS[defaultPerm] ?? 0) && !task.permissionConfirmedAt) {
+                const next = computeNextRun(task.cron, now)
+                store.updateTask(task.id, { lastRunAt: now, nextRunAt: next || 0 })
+                store.addTransition({
+                  taskId: task.id,
+                  fromCol: task.column,
+                  toCol: task.column,
+                  source: 'tool',
+                  detail: 'cron: run rejected (elevated permission required)',
+                })
+                continue
+              }
+            }
+            const picked = resolveModel({
+              requested: { model: task.model, provider: task.provider },
+              fallback: ctx.get('agentDefaultModel')?.currentSelection?.(),
+            })
+            if (picked.model) {
+              await runTask({
+                agents: ctx.agents,
+                store,
+                task,
+                config: getConfig(),
+                provider: picked.provider,
+                model: picked.model,
+                mintSessionId: () => SessionId(`kanban-${task.id}-${randomUUID()}`),
+                createMessage: createUserMessage,
+                logger: ctx.logger,
+                workspaceRegistry: ctx.get('workspaceRegistry'),
+                claimAs: 'cron',
+              })
+              syncPower()
+            }
+            const next = computeNextRun(task.cron, now)
+            store.updateTask(task.id, { lastRunAt: now, nextRunAt: next || 0 })
+          }
+        } catch (err) {
+          ctx.logger?.warn?.(`dsh-kanban: cron scheduler error: ${err?.message}`)
+        }
+      }, 30_000)
+      if (typeof cronTimer.unref === 'function') cronTimer.unref()
+    }
+    armCron()
+    rearmers.add(armCron)
+    return () => { rearmers.delete(armCron); clearInterval(cronTimer) }
+  }, 'dsh-kanban: cron scheduler')
+
+  const outbox = createOutbox({ gitea: git, get store() { return store }, logger: ctx.logger })
+
+  const queueOutbound = (taskId, column) => {
+    if (getConfig().pushToGitea !== true) return
+    const task = store.getTask(taskId)
+    if (task === undefined) return
+    const ops = planOutbound(task, column, getConfig())
+    if (ops.length > 0) outbox.push(taskId, ops)
+  }
+
+  let discoveredOwner
+  const defaultOwner = async () => {
+    const named = String(getConfig().giteaOwner ?? '').trim()
+    if (named !== '') return named
+    for (const task of store.listWatchable()) {
+      if (typeof task.owner === 'string' && task.owner !== '') return task.owner
+    }
+    if (discoveredOwner !== undefined) return discoveredOwner
+    const orgs = await gitea.listOrgs()
+    if (orgs.length === 1) { discoveredOwner = orgs[0]; return discoveredOwner }
+    return undefined
+  }
+
+  const syncState = createSyncState()
+
+  let syncing = false
+  const runSync = async () => {
+    if (syncing) return { skipped: true }
+    syncing = true
+    syncState.started()
+    try {
+      const mode = String(getConfig()?.gitProvider || 'auto').toLowerCase()
+      const providersToSync = []
+      if (mode === 'github') {
+        providersToSync.push(github)
+      } else if (mode === 'gitea') {
+        providersToSync.push(gitea)
+      } else {
+        if (await gitea.isConfigured()) providersToSync.push(gitea)
+        if (await github.isConfigured()) providersToSync.push(github)
+        if (providersToSync.length === 0) providersToSync.push(gitea)
+      }
+
+      let taken = { added: 0, skipped: 0, failed: 0 }
+      for (const p of providersToSync) {
+        const owner = p === github
+          ? (String(getConfig()?.githubOwner ?? '').trim() || await p.me().catch(() => ''))
+          : await defaultOwner()
+        const res = await intakeAll({
+          gitea: p, store, config: getConfig(), owner, logger: ctx.logger,
+        })
+        if (res && typeof res.added === 'number') {
+          taken.added = (taken.added || 0) + res.added
+          taken.skipped = (taken.skipped || 0) + (res.skipped || 0)
+          taken.failed = (taken.failed || 0) + (res.failed || 0)
+        }
+        if (res?.problem) taken.problem = res.problem
+      }
+      const out = await syncAll({ gitea: git, store, logger: ctx.logger })
+      const tidied = archiveOverdue({ store, config: getConfig() })
+      const pushed = await outbox.flush()
+      syncState.finished(out.problem === undefined && taken.problem !== undefined
+        ? { ...out, problem: taken.problem }
+        : out)
+      return { ...out, pushed, taken, tidied }
+    } catch (error) {
+      syncState.failedToStart('sync', error?.message)
+      throw error
+    } finally {
+      syncing = false
+    }
+  }
+
+  ctx.effect(() => {
+    let timer
+    const arm = () => {
+      const seconds = Number(getConfig().syncIntervalSec) || 0
+      clearInterval(timer)
+      timer = undefined
+      if (seconds <= 0) return
+      timer = setInterval(() => { runSync().catch(() => {}) }, Math.max(seconds, 15) * 1000)
+      if (typeof timer.unref === 'function') timer.unref()
+    }
+    arm()
+    rearmers.add(arm)
+    return () => { rearmers.delete(arm); clearInterval(timer) }
+  }, 'dsh-kanban: sync timer')
+
+  ctx.effect(() => {
+    let watchdogTimer
+    const armWatchdog = () => {
+      clearInterval(watchdogTimer)
+      watchdogTimer = undefined
+      if (getConfig().watchdogEnabled === false || !watchdog) return
+      watchdogTimer = setInterval(() => {
+        try {
+          watchdog.checkTasks({
+            store,
+            agents: ctx.agents,
+            config: getConfig(),
+            eventHub,
+            logger: ctx.logger,
+          })
+        } catch (err) {
+          ctx.logger?.warn?.(`dsh-kanban: watchdog check error: ${err?.message}`)
+        }
+      }, 15000)
+      if (typeof watchdogTimer.unref === 'function') watchdogTimer.unref()
+    }
+    armWatchdog()
+    rearmers.add(armWatchdog)
+    return () => { rearmers.delete(armWatchdog); clearInterval(watchdogTimer) }
+  }, 'dsh-kanban: watchdog timer')
+
+  return { syncState, runSync, defaultOwner, queueOutbound }
+}

package/lib/store.js

@@ -76,6 +76,11 @@ CREATE TABLE IF NOT EXISTS tasks (
   forge                 TEXT NOT NULL DEFAULT '',
   permissionConfirmedTier TEXT NOT NULL DEFAULT '',
   queuedRequest         TEXT NOT NULL DEFAULT '',
+  stalled               INTEGER NOT NULL DEFAULT 0,
+  stalledReason         TEXT NOT NULL DEFAULT '',
+  stalledAt             INTEGER NOT NULL DEFAULT 0,
+  blockedBy             TEXT NOT NULL DEFAULT '[]',
+  inceptionSnapshotId   TEXT NOT NULL DEFAULT '',
   updatedAt    INTEGER NOT NULL
 );
 CREATE INDEX IF NOT EXISTS tasks_board_col ON tasks(board, col, position);
@@ -110,14 +115,16 @@ const WRITABLE = [
   'workflowRunId', 'workflowStatus', 'permissionConfirmedTier', 'forge', 'queuedRequest',
   'verificationCommand', 'verificationStatus',
   'costMetrics', 'costLimitExceeded',
+  'stalled', 'stalledReason', 'stalledAt',
+  'blockedBy', 'inceptionSnapshotId',
 ]
 
 /** Valid transition sources; unexpected values are rejected to preserve log integrity. */
-const SOURCES = new Set(['manual', 'session', 'gitea', 'github', 'tool', 'workflow'])
+const SOURCES = new Set(['manual', 'session', 'gitea', 'github', 'tool', 'workflow', 'watchdog'])
 
 function rowToTask(row) {
   if (row === undefined) return undefined
-  const { col, labels, waiting, labelColors, runs, checklist, report, comments, rejectReason, rejectedAt, isEpic, parentId, ...rest } = row
+  const { col, labels, waiting, labelColors, runs, checklist, report, comments, rejectReason, rejectedAt, isEpic, parentId, stalled, blockedBy, inceptionSnapshotId, ...rest } = row
   let parsedChecklist = []
   try {
     const value = JSON.parse(checklist ?? '[]')
@@ -173,6 +180,13 @@ function rowToTask(row) {
       return rest.costMetrics && typeof rest.costMetrics === 'object' ? rest.costMetrics : null;
     })(),
     costLimitExceeded: rest.costLimitExceeded === 1 || rest.costLimitExceeded === true,
+    blockedBy: (() => {
+      try {
+        const val = JSON.parse(blockedBy ?? '[]')
+        return Array.isArray(val) ? val.filter((x) => typeof x === 'string') : []
+      } catch { return [] }
+    })(),
+    inceptionSnapshotId: typeof inceptionSnapshotId === 'string' ? inceptionSnapshotId : (typeof rest.inceptionSnapshotId === 'string' ? rest.inceptionSnapshotId : ''),
   }
 }
 
@@ -265,6 +279,11 @@ export function openStore({ dir }) {
     ['verificationStatus', "TEXT NOT NULL DEFAULT ''"],
     ['costMetrics', "TEXT NOT NULL DEFAULT ''"],
     ['costLimitExceeded', "INTEGER NOT NULL DEFAULT 0"],
+    ['stalled', 'INTEGER NOT NULL DEFAULT 0'],
+    ['stalledReason', "TEXT NOT NULL DEFAULT ''"],
+    ['stalledAt', 'INTEGER NOT NULL DEFAULT 0'],
+    ['blockedBy', "TEXT NOT NULL DEFAULT '[]'"],
+    ['inceptionSnapshotId', "TEXT NOT NULL DEFAULT ''"],
   ]) {
     try { db.exec(`ALTER TABLE tasks ADD COLUMN ${column} ${definition}`) } catch { /* column already exists */ }
   }
@@ -607,6 +626,8 @@ export function openStore({ dir }) {
         else if (key === 'syncedAt') values.push(Number(patch[key]) || 0)
         else if (key === 'isEpic') values.push(patch[key] ? 1 : 0)
         else if (key === 'parentId') values.push(String(patch[key] ?? ''))
+        else if (key === 'blockedBy') values.push(Array.isArray(patch[key]) ? JSON.stringify(patch[key]) : (typeof patch[key] === 'string' ? patch[key] : '[]'))
+        else if (key === 'inceptionSnapshotId') values.push(String(patch[key] ?? ''))
         else values.push(patch[key] ?? null)
       }
       if (fields.length > 0) {

package/lib/time-machine.js

@@ -0,0 +1,214 @@
+// Integration service for @goodandready/dsh-time-machine snapshot and rollback capabilities.
+// Provides automatic inception snapshots on task start and one-click rollback to clean state.
+// Degrades gracefully when @goodandready/dsh-time-machine plugin is not installed in DSH profile.
+
+import { resolveTaskWorktreePath } from './worktree.js'
+
+/**
+ * Check whether timeMachineEngine is available in the Cordis context.
+ *
+ * @param {object} ctx Cordis context or harness
+ * @returns {boolean} true if time machine engine is available
+ */
+export function isTimeMachineAvailable(ctx) {
+  if (!ctx || typeof ctx !== 'object') return false
+  const engine = ctx.timeMachineEngine || (typeof ctx.get === 'function' ? (ctx.get('timeMachineEngine') || ctx.get('timeMachine')) : null)
+  return !!(engine && (typeof engine.createSnapshot === 'function' || typeof engine.rollbackSnapshot === 'function' || typeof engine.listSnapshots === 'function'))
+}
+
+/**
+ * Resolve the timeMachineEngine instance from context.
+ *
+ * @param {object} ctx Cordis context
+ * @returns {object|null}
+ */
+export function getTimeMachineEngine(ctx) {
+  if (!ctx || typeof ctx !== 'object') return null
+  const engine = ctx.timeMachineEngine || (typeof ctx.get === 'function' ? (ctx.get('timeMachineEngine') || ctx.get('timeMachine')) : null)
+  if (engine && (typeof engine.createSnapshot === 'function' || typeof engine.rollbackSnapshot === 'function' || typeof engine.listSnapshots === 'function')) {
+    return engine
+  }
+  return null
+}
+
+/**
+ * Resolve the directory path to snapshot for a task.
+ *
+ * @param {{task: object, config?: object, env?: object, cwdOf?: Function}} options
+ * @returns {string}
+ */
+export function resolveSnapshotDir({ task, config, env, cwdOf }) {
+  if (task?.worktree && typeof task.worktree === 'string' && task.worktree.trim() !== '') {
+    return task.worktree.trim()
+  }
+  try {
+    const resolved = resolveTaskWorktreePath({ task, config, env, cwdOf: cwdOf || (() => process.cwd()) })
+    if (resolved) return resolved
+  } catch {
+    /* fallback to cwd */
+  }
+  return typeof cwdOf === 'function' ? cwdOf() : process.cwd()
+}
+
+/**
+ * Automatically create inception snapshot when task moves to in-progress.
+ *
+ * @param {{ctx: object, task: object, config?: object, env?: object, cwdOf?: Function, store?: object, logger?: object}} options
+ * @returns {Promise<{available: boolean, created: boolean, snapshotId?: string, alreadyExists?: boolean, snapshot?: object, error?: string}>}
+ */
+export async function createInceptionSnapshot({ ctx, task, config, env, cwdOf, store, logger }) {
+  const engine = getTimeMachineEngine(ctx)
+  if (!engine) {
+    return { available: false, created: false }
+  }
+
+  if (task?.inceptionSnapshotId && typeof task.inceptionSnapshotId === 'string' && task.inceptionSnapshotId.trim() !== '') {
+    return {
+      available: true,
+      created: false,
+      alreadyExists: true,
+      snapshotId: task.inceptionSnapshotId.trim(),
+    }
+  }
+
+  const targetDir = resolveSnapshotDir({ task, config, env, cwdOf })
+  const label = `Inception: ${task?.id || 'task'} (${task?.title || 'untitled'})`
+  const sessionId = `task-${task?.id || 'default'}`
+
+  try {
+    const snapshot = await engine.createSnapshot(label, {
+      sessionId,
+      cwd: targetDir,
+      skipIfNoChanges: false,
+    })
+
+    if (snapshot?.id && store && typeof store.updateTask === 'function' && task?.id) {
+      store.updateTask(task.id, { inceptionSnapshotId: snapshot.id })
+    }
+
+    return {
+      available: true,
+      created: true,
+      snapshotId: snapshot?.id,
+      snapshot,
+    }
+  } catch (err) {
+    logger?.warn?.('[dsh-kanban] Failed to create inception snapshot:', err?.message || err)
+    return {
+      available: true,
+      created: false,
+      error: err?.message || String(err),
+    }
+  }
+}
+
+/**
+ * Manually create a checkpoint snapshot for a task.
+ *
+ * @param {{ctx: object, task: object, label?: string, config?: object, env?: object, cwdOf?: Function, logger?: object}} options
+ * @returns {Promise<{available: boolean, created: boolean, snapshot?: object, error?: string}>}
+ */
+export async function createCheckpointSnapshot({ ctx, task, label, config, env, cwdOf, logger }) {
+  const engine = getTimeMachineEngine(ctx)
+  if (!engine) {
+    return { available: false, created: false }
+  }
+
+  const targetDir = resolveSnapshotDir({ task, config, env, cwdOf })
+  const snapshotLabel = `Checkpoint: ${label || 'manual'} (${task?.id || 'task'})`
+  const sessionId = `task-${task?.id || 'default'}`
+
+  try {
+    const snapshot = await engine.createSnapshot(snapshotLabel, {
+      sessionId,
+      cwd: targetDir,
+      skipIfNoChanges: false,
+    })
+    return {
+      available: true,
+      created: true,
+      snapshot,
+    }
+  } catch (err) {
+    logger?.warn?.('[dsh-kanban] Failed to create checkpoint snapshot:', err?.message || err)
+    return {
+      available: true,
+      created: false,
+      error: err?.message || String(err),
+    }
+  }
+}
+
+/**
+ * Roll back task files to a snapshot (default: inception snapshot).
+ *
+ * @param {{ctx: object, task: object, snapshotId?: string, config?: object, env?: object, cwdOf?: Function, logger?: object}} options
+ * @returns {Promise<{available: boolean, rolledBack: boolean, snapshotId?: string, result?: object, error?: string, message?: string}>}
+ */
+export async function rollbackToSnapshot({ ctx, task, snapshotId, config, env, cwdOf, logger }) {
+  const engine = getTimeMachineEngine(ctx)
+  if (!engine) {
+    return {
+      available: false,
+      rolledBack: false,
+      error: 'time-machine-unavailable',
+      message: 'Plugin @goodandready/dsh-time-machine is not installed or active in this profile.',
+    }
+  }
+
+  const targetId = snapshotId || task?.inceptionSnapshotId
+  if (!targetId || typeof targetId !== 'string' || targetId.trim() === '') {
+    return {
+      available: true,
+      rolledBack: false,
+      error: 'no-snapshot-id',
+      message: 'No snapshot ID specified and task has no inception snapshot.',
+    }
+  }
+
+  const targetDir = resolveSnapshotDir({ task, config, env, cwdOf })
+
+  try {
+    const result = await engine.rollbackSnapshot(String(targetId).trim(), {
+      confirm: true,
+      cwd: targetDir,
+    })
+    return {
+      available: true,
+      rolledBack: true,
+      snapshotId: targetId,
+      result,
+    }
+  } catch (err) {
+    logger?.error?.('[dsh-kanban] Failed to rollback snapshot:', err?.message || err)
+    return {
+      available: true,
+      rolledBack: false,
+      error: 'rollback-failed',
+      message: err?.message || String(err),
+    }
+  }
+}
+
+/**
+ * List snapshots for a task.
+ *
+ * @param {{ctx: object, task: object}} options
+ * @returns {Promise<Array<object>>}
+ */
+export async function listTaskSnapshots({ ctx, task }) {
+  const engine = getTimeMachineEngine(ctx)
+  if (!engine || !task?.id) return []
+
+  const sessionId = `task-${task.id}`
+  try {
+    if (typeof engine.listSnapshots === 'function') {
+      const list = engine.listSnapshots(sessionId)
+      return Array.isArray(list) ? list : []
+    }
+  } catch {
+    /* ignore error */
+  }
+  return []
+}
+

package/lib/watchdog.js

@@ -0,0 +1,169 @@
+/**
+ * Watchdog timer and Circuit Breaker service for agent tasks.
+ *
+ * Automatically monitors tasks in 'in-progress'.
+ * If a task is inactive longer than watchdogStallTimeoutMin or incurs
+ * watchdogMaxConsecutiveErrors consecutive execution errors,
+ * the circuit breaker trips:
+ * 1. The agent session is aborted/paused to avoid burning quota.
+ * 2. The task is marked as stalled with diagnostic detail.
+ * 3. A diagnostic transition is added to the task journal.
+ * 4. A 'task:change' event is broadcast via eventHub.
+ *
+ * Tasks can be resumed manually via resumeTask or /task/:id/resume.
+ */
+export class WatchdogService {
+  constructor() {
+    this.consecutiveErrors = new Map()
+    this.lastActive = new Map()
+    this.lastError = new Map()
+  }
+
+  recordActivity(taskId, _type = 'activity') {
+    if (!taskId) return
+    this.lastActive.set(taskId, Date.now())
+  }
+
+  recordError(taskId, error) {
+    if (!taskId) return
+    const count = (this.consecutiveErrors.get(taskId) || 0) + 1
+    this.consecutiveErrors.set(taskId, count)
+    const msg = typeof error === 'string' ? error : (error?.message || error?.name || 'Execution error')
+    this.lastError.set(taskId, msg)
+    this.lastActive.set(taskId, Date.now())
+    return count
+  }
+
+  clearError(taskId) {
+    if (!taskId) return
+    this.consecutiveErrors.delete(taskId)
+    this.lastError.delete(taskId)
+  }
+
+  clearTask(taskId) {
+    if (!taskId) return
+    this.consecutiveErrors.delete(taskId)
+    this.lastError.delete(taskId)
+    this.lastActive.delete(taskId)
+  }
+
+  checkTask(task, options = {}) {
+    const { config = {}, now = Date.now() } = options
+    if (config.watchdogEnabled === false) return { shouldTrip: false }
+    if (!task || task.column !== 'in-progress' || task.stalled) return { shouldTrip: false }
+
+    const timeoutMs = (Number(config.watchdogStallTimeoutMin) || 15) * 60 * 1000
+    const maxErrors = Number(config.watchdogMaxConsecutiveErrors) || 5
+
+    // Check consecutive errors
+    const errCount = this.consecutiveErrors.get(task.id) || 0
+    if (errCount >= maxErrors) {
+      const lastErr = this.lastError.get(task.id) || 'ToolExecutionError'
+      return {
+        shouldTrip: true,
+        reason: `Circuit breaker tripped: ${errCount} consecutive execution errors (${lastErr})`,
+        errCount,
+      }
+    }
+
+    // Check inactivity timeout
+    const last = this.lastActive.get(task.id) || task.updatedAt || task.columnAt || task.createdAt || now
+    const idleMs = now - last
+    if (idleMs >= timeoutMs) {
+      const idleMin = Math.round(idleMs / 60000)
+      return {
+        shouldTrip: true,
+        reason: `Watchdog timeout: task inactive for ${idleMin} minutes (threshold ${config.watchdogStallTimeoutMin || 15}m)`,
+        idleMs,
+      }
+    }
+
+    return { shouldTrip: false }
+  }
+
+  tripTask(task, reason, options = {}) {
+    const { store, agents, eventHub, logger } = options
+    if (!task) return
+
+    // 1. Abort/pause session if running
+    if (task.sessionId && agents) {
+      try {
+        const agent = agents.get?.(task.sessionId)
+        if (agent && typeof agent.abort === 'function') {
+          agent.abort('watchdog: circuit breaker tripped')
+        } else if (agent && typeof agent.pause === 'function') {
+          agent.pause()
+        }
+      } catch (err) {
+        logger?.warn?.(`dsh-kanban: watchdog failed to abort agent for session ${task.sessionId}: ${err?.message}`)
+      }
+    }
+
+    // 2. Update task in store
+    if (store && typeof store.updateTask === 'function') {
+      store.updateTask(task.id, {
+        stalled: 1,
+        stalledReason: reason,
+        stalledAt: Date.now(),
+      })
+
+      // 3. Journal transition
+      if (typeof store.addTransition === 'function') {
+        store.addTransition({
+          taskId: task.id,
+          fromCol: task.column,
+          toCol: task.column,
+          source: 'watchdog',
+          detail: reason,
+        })
+      }
+    }
+
+    // 4. Broadcast event
+    eventHub?.broadcast?.('task:change', {
+      taskId: task.id,
+      action: 'stalled',
+      stalled: true,
+      reason,
+    })
+
+    logger?.warn?.(`dsh-kanban: watchdog tripped for task ${task.id}: ${reason}`)
+  }
+
+  checkTasks(options = {}) {
+    const { store, agents, config = {}, eventHub, logger } = options
+    if (config.watchdogEnabled === false || !store) return []
+
+    const tripped = []
+    const inProgressTasks = store.listTasks({ column: 'in-progress' })
+    const now = Date.now()
+
+    for (const task of inProgressTasks) {
+      const check = this.checkTask(task, { config, now })
+      if (check.shouldTrip) {
+        this.tripTask(task, check.reason, { store, agents, eventHub, logger })
+        tripped.push({ taskId: task.id, reason: check.reason })
+      }
+    }
+    return tripped
+  }
+
+  resumeTask(options = {}) {
+    const { store, taskId, eventHub } = options
+    if (!taskId) return
+    if (store && typeof store.updateTask === 'function') {
+      store.updateTask(taskId, {
+        stalled: 0,
+        stalledReason: '',
+        stalledAt: 0,
+      })
+    }
+    this.clearTask(taskId)
+    this.recordActivity(taskId, 'resume')
+    eventHub?.broadcast?.('task:change', { taskId, action: 'resumed', stalled: false })
+  }
+}
+
+export function createWatchdogService() {
+  return new WatchdogService()
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-kanban",
-  "version": "0.2.34",
+  "version": "0.2.36",
   "description": "Visual Kanban board for DeepSeek Harness: Gitea and GitHub-backed tasks, workflow columns, and a dedicated agent session per task.",
   "type": "module",
   "main": "lib/index.js",