@goodandready/dsh-kanban 0.2.33 → 0.2.35

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,9 @@ 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,
   updatedAt    INTEGER NOT NULL
 );
 CREATE INDEX IF NOT EXISTS tasks_board_col ON tasks(board, col, position);
@@ -110,14 +113,15 @@ const WRITABLE = [
   'workflowRunId', 'workflowStatus', 'permissionConfirmedTier', 'forge', 'queuedRequest',
   'verificationCommand', 'verificationStatus',
   'costMetrics', 'costLimitExceeded',
+  'stalled', 'stalledReason', 'stalledAt',
 ]
 
 /** 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, ...rest } = row
   let parsedChecklist = []
   try {
     const value = JSON.parse(checklist ?? '[]')
@@ -265,6 +269,9 @@ 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'],
   ]) {
     try { db.exec(`ALTER TABLE tasks ADD COLUMN ${column} ${definition}`) } catch { /* column already exists */ }
   }

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/lib/worktree.js

@@ -71,7 +71,32 @@ export function safeRepoKey(task) {
 /**
  * Resolve root directory for all managed worktrees.
  */
+/**
+ * Check if worktree directory exists locally or remotely.
+ *
+ * @param {string} worktreePath
+ * @param {Function} [gitRunner]
+ * @returns {Promise<boolean>}
+ */
+export async function safeWorktreeExists(worktreePath, gitRunner) {
+  if (!worktreePath) return false
+  if (existsSync(worktreePath)) return true
+  if (typeof gitRunner === 'function') {
+    try {
+      const res = await gitRunner(['rev-parse', '--is-inside-work-tree'], worktreePath)
+      return res.stdout?.trim() === 'true'
+    } catch {
+      return false
+    }
+  }
+  return false
+}
+
 export function resolveWorktreeRoot(config, env = process.env, cwdOf = () => process.cwd()) {
+  if (config?.remoteMode && config?.remoteRoot) {
+    const root = String(config.remoteRoot).trim().replace(/\/+$/, '')
+    return `${root}/.worktrees`
+  }
   const custom = typeof config?.worktreeRoot === 'string' ? config.worktreeRoot.trim() : ''
   if (custom !== '') {
     return isAbsolute(custom) ? resolve(custom) : resolve(join(cwdOf(), custom))
@@ -105,6 +130,12 @@ export function isPathFenced(targetPath, rootPath) {
 }
 
 export function resolveTaskWorktreePath({ task, config, env, cwdOf }) {
+  if (config?.remoteMode) {
+    const root = resolveWorktreeRoot(config, env, cwdOf)
+    const repoKey = safeRepoKey(task)
+    const taskId = typeof task?.id === 'string' && task.id.trim() !== '' ? task.id.trim() : 'task'
+    return `${root}/${repoKey}/${taskId}`
+  }
   const root = resolveWorktreeRoot(config, env, cwdOf)
   const repoKey = safeRepoKey(task)
   const taskId = typeof task?.id === 'string' && task.id.trim() !== '' ? task.id.trim() : 'task'
@@ -261,7 +292,8 @@ function isSubmoduleDrift(worktreePath, line) {
  * Excludes submodule noise and gitlink drift (#213).
  */
 export async function checkWorktreeDirty({ worktreePath, gitRunner = defaultGitRunner }) {
-  if (!worktreePath || !existsSync(worktreePath)) {
+  const exists = await safeWorktreeExists(worktreePath, gitRunner)
+  if (!worktreePath || !exists) {
     return { dirty: false, files: [] }
   }
   try {
@@ -289,7 +321,8 @@ export async function removeTaskWorktree({
   gitRunner = defaultGitRunner,
   rootPath,
 }) {
-  if (!worktreePath || !existsSync(worktreePath)) {
+  const exists = await safeWorktreeExists(worktreePath, gitRunner)
+  if (!worktreePath || !exists) {
     return { removed: false, reason: 'not-found' }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-kanban",
-  "version": "0.2.33",
+  "version": "0.2.35",
   "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",