@goodandready/dsh-kanban 0.2.31 → 0.2.33

package/lib/cost-telemetry.js

@@ -0,0 +1,146 @@
+/**
+ * Token and cost telemetry integration with @goodandready/dsh-cost-meter (#374).
+ * All functions fail-soft without throwing when cost-meter is absent.
+ */
+
+/**
+ * Check whether @goodandready/dsh-cost-meter plugin is active in current runtime.
+ *
+ * @param {object} ctx - Cordis context
+ * @returns {boolean}
+ */
+export function isCostMeterAvailable(ctx) {
+  if (!ctx || typeof ctx !== 'object') return false
+  try {
+    if (ctx.costMeter || (typeof ctx.get === 'function' && ctx.get('costMeter'))) return true
+    if (ctx.settings && typeof ctx.settings.describe === 'function') {
+      const rows = ctx.settings.describe({ redactSecrets: true })
+      if (Array.isArray(rows) && rows.some((r) => r?.ns === 'dsh-cost-meter')) return true
+    }
+    if (ctx.registry && typeof ctx.registry[Symbol.iterator] === 'function') {
+      for (const [plugin] of ctx.registry) {
+        if (plugin === '@goodandready/dsh-cost-meter' || plugin?.name === '@goodandready/dsh-cost-meter') {
+          return true
+        }
+      }
+    }
+    return false
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Extract aggregated token usage from a session's costByModel projection view.
+ *
+ * @param {object} projectionView - View object from usageByModelProjection
+ * @returns {{
+ *   totalTokens: number,
+ *   uncachedInputTokens: number,
+ *   outputTokens: number,
+ *   cacheReadTokens: number,
+ *   cacheWriteTokens: number,
+ *   turnsCount: number,
+ *   models: Array<string>
+ * }}
+ */
+export function extractSessionUsage(projectionView) {
+  const result = {
+    totalTokens: 0,
+    uncachedInputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    turnsCount: 0,
+    models: [],
+  }
+  if (!projectionView || typeof projectionView !== 'object') return result
+
+  const modelsList = Array.isArray(projectionView.models) ? projectionView.models : []
+  for (const m of modelsList) {
+    const key = (m.provider ? m.provider + '/' : '') + (m.model || '')
+    if (key && !result.models.includes(key)) result.models.push(key)
+    const slots = m.slots && typeof m.slots === 'object' ? m.slots : {}
+    for (const slotKey of Object.keys(slots)) {
+      const b = slots[slotKey] || {}
+      result.uncachedInputTokens += Number(b.uncachedInputTokens) || 0
+      result.outputTokens += Number(b.outputTokens) || 0
+      result.cacheReadTokens += Number(b.cacheReadTokens) || 0
+      result.cacheWriteTokens += Number(b.cacheWriteTokens) || 0
+    }
+  }
+
+  if (Array.isArray(projectionView.turns)) {
+    result.turnsCount = projectionView.turns.length
+    if (result.totalTokens === 0 && projectionView.turns.length > 0) {
+      for (const t of projectionView.turns) {
+        result.uncachedInputTokens += Number(t.uncachedInputTokens) || 0
+        result.outputTokens += Number(t.outputTokens) || 0
+        result.cacheReadTokens += Number(t.cacheReadTokens) || 0
+        result.cacheWriteTokens += Number(t.cacheWriteTokens) || 0
+      }
+    }
+  }
+
+  result.totalTokens = result.uncachedInputTokens + result.outputTokens + result.cacheReadTokens + result.cacheWriteTokens
+  return result
+}
+
+/**
+ * Calculate cost for token usage given rate schedule or fallback tariff.
+ * Default tariff: standard DeepSeek rates ($0.14/M input, $0.28/M output, $0.014/M cache hit).
+ *
+ * @param {{
+ *   usage: object,
+ *   schedule?: object,
+ *   usdRate?: number,
+ *   currency?: string
+ * }} options
+ * @returns {{
+ *   costUsd: number,
+ *   costFormatted: string,
+ *   currency: string
+ * }}
+ */
+export function calculateTokenCost({ usage, schedule, usdRate = 1, currency = '$' }) {
+  if (!usage || typeof usage !== 'object') {
+    return { costUsd: 0, costFormatted: currency + '0.00', currency }
+  }
+
+  const uncachedInput = Number(usage.uncachedInputTokens) || 0
+  const output = Number(usage.outputTokens) || 0
+  const cacheRead = Number(usage.cacheReadTokens) || 0
+  const cacheWrite = Number(usage.cacheWriteTokens) || 0
+
+  const rateInput = Number(schedule?.inputPerMillion ?? schedule?.input) || 0.14
+  const rateOutput = Number(schedule?.outputPerMillion ?? schedule?.output) || 0.28
+  const rateCacheRead = Number(schedule?.cacheReadPerMillion ?? schedule?.cacheHit) || 0.014
+  const rateCacheWrite = Number(schedule?.cacheWritePerMillion) || rateInput
+
+  const costUsd = (uncachedInput * rateInput + output * rateOutput + cacheRead * rateCacheRead + cacheWrite * rateCacheWrite) / 1_000_000
+  const converted = costUsd * (Number(usdRate) > 0 ? Number(usdRate) : 1)
+
+  const costFormatted = currency + (converted < 0.01 && converted > 0 ? '<0.01' : converted.toFixed(2))
+
+  return {
+    costUsd: Math.round(costUsd * 10000) / 10000,
+    costFormatted,
+    currency,
+  }
+}
+
+/**
+ * Check whether task cost exceeds configured budget limit.
+ *
+ * @param {{ costUsd: number, limit: number }} options
+ * @returns {{ exceeded: boolean, limit: number, costUsd: number }}
+ */
+export function checkCostLimit({ costUsd = 0, limit = 0 }) {
+  const numLimit = Number(limit) || 0
+  if (numLimit <= 0) return { exceeded: false, limit: 0, costUsd }
+  return {
+    exceeded: costUsd >= numLimit,
+    limit: numLimit,
+    costUsd,
+  }
+}

package/lib/index.js

@@ -1,3 +1,4 @@
+import { verifyAndRecordGate } from './verification.js'
 import { registerPluginUpdater } from './updater.js'
 // dsh-kanban — task board for DeepSeek Harness.
 //
@@ -34,6 +35,7 @@ import {
   exportTasksCsv,
   handleCleanupWorktree,
   handleTaskDiff,
+  handleTaskDiscard,
   handleTaskCommits,
   handleTaskMerge,
   handleTaskWorktreeStatus,
@@ -49,7 +51,9 @@ import {
   handleCreateSubtask,
   handleToggleChecklistItem,
   handleCreateTaskPr,
+  handleTaskNudge,
 } from './routes.js'
+import { isCostMeterAvailable } from './cost-telemetry.js'
 import { listImportable, importIssue, refreshTask, searchRepos, createProjectTask } from './import.js'
 import {
   runTask, resolveModel, buildStartMessage,
@@ -865,7 +869,20 @@ export function apply(ctx, config) {
   /**
    * Return active agent state or undefined if session is inactive.
    */
-  const liveOf = (sessionId) => ctx.agents.get(sessionId)?.status
+  const liveOf = (sessionId) => {
+    try {
+      const a = ctx.agents?.get?.(sessionId);
+      if (!a) return undefined;
+      return {
+        status: a.status || (typeof a.isIdle === 'function' && a.isIdle() ? 'idle' : 'running'),
+        state: a.state || a.lifecycleState,
+        step: a.step || a.currentStep || a.stateDetail || a.activity || '',
+        activity: a.activity || a.statusDetail || '',
+      };
+    } catch {
+      return undefined;
+    }
+  };
 
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
@@ -883,6 +900,7 @@ export function apply(ctx, config) {
         sync: syncState.snapshot(),
         // Resolved project root passed with board payload for session launch modal.
         projectRoot: rootOf(getConfig()),
+        costMeterAvailable: isCostMeterAvailable(ctx),
       }))
     },
   }), 'dsh-kanban: board route')
@@ -1151,8 +1169,31 @@ export function apply(ctx, config) {
       try {
         const input = await readBody(req)
         if (req.method === 'POST' && action === 'move') {
-          // Manual move dispatches stop command to agent prior to updating card column.
           const was = store.getTask(id)
+          if (was === undefined) { writeJson(res, 404, { error: 'task-not-found' }); return }
+
+          // Automated Verification Gate (#372): intercept transition to review
+          if (input.column === 'review' && was.column !== 'review') {
+            const gateResult = await verifyAndRecordGate({
+              task: was,
+              config: getConfig(),
+              store,
+              agents: ctx.agents,
+              createMessage: createUserMessage,
+            })
+            if (!gateResult.allowed) {
+              writeJson(res, 422, {
+                error: 'verification-failed',
+                command: gateResult.verification.command,
+                exitCode: gateResult.verification.exitCode,
+                log: gateResult.verification.logSnippet,
+                task: store.getTask(id),
+              })
+              return
+            }
+          }
+
+          // Manual move dispatches stop command to agent prior to updating card column.
           const acted = was !== undefined && input.column !== was.column
             ? dispatchMove({
               agents: ctx.agents, task: was, column: input.column,
@@ -1193,8 +1234,32 @@ export function apply(ctx, config) {
           writeJson(res, resObj.status, resObj.body)
           return
         }
+        if (req.method === 'POST' && action === 'discard') {
+          const resObj = await handleTaskDiscard({
+            task: store.getTask(id),
+            file: input?.file,
+            discardTaskFile,
+          })
+          if (resObj?.body?.success) {
+            eventHub.broadcast('task:change', { taskId: id, action: 'discard', file: input?.file })
+          }
+          writeJson(res, resObj.status, resObj.body)
+          return
+        }
+        if (req.method === 'POST' && (action === 'nudge' || (input && input.action === 'nudge'))) {
+          const resObj = await handleTaskNudge({
+            store,
+            id,
+            prompt: input?.prompt || input?.text,
+            agents: ctx.agents,
+            createMessage: createUserMessage,
+            eventHub,
+          })
+          writeJson(res, resObj.status, resObj.body)
+          return
+        }
         if (req.method === 'GET' && action === 'diff') {
-          const resObj = await handleTaskDiff({ task: store.getTask(id), getTaskDiff })
+          const resObj = await handleTaskDiff({ task: store.getTask(id), getTaskDiff, getTaskDiffInspector })
           writeJson(res, resObj.status, resObj.body)
           return
         }

package/lib/routes.js

@@ -308,10 +308,23 @@ function withPlan(task, liveOf, config, now, sameSession) {
   try {
     if (typeof liveOf === 'function' && task.sessionId) live = liveOf(task.sessionId)
   } catch { live = undefined }
+  const liveStatus = typeof live === 'object' && live !== null ? live.status : live
+  const liveStep = typeof live === 'object' && live !== null
+    ? (live.step || live.activity || live.stateDetail || '')
+    : ''
+
+  const costMetrics = task.costMetrics || null
+  const costLimitExceeded = (config?.costMeterEnabled !== false && Number(config?.taskCostLimit) > 0 && costMetrics?.costUsd)
+    ? costMetrics.costUsd >= Number(config.taskCostLimit)
+    : Boolean(task.costLimitExceeded)
+
   return {
     ...task,
     plan: { items: planItems(plan), progress: planProgress(plan) },
-    state: taskState({ task, live }),
+    state: taskState({ task, live: liveStatus }),
+    liveStep: liveStep || task.liveStep || '',
+    costMetrics,
+    costLimitExceeded,
     // Queue position calculated dynamically across active tasks in same session.
     queuePos: queuePosition(task, sameSession),
     // Label facets extracted on server for consistent client filtering.
@@ -344,7 +357,7 @@ function orderForBoard(tasks, columns) {
 /**
  * Build board response payload: columns in canonical order, tasks, and limits.
  */
-export function buildBoard({ store, config, board = 'main', repo, liveOf, sync, projectRoot }) {
+export function buildBoard({ store, config, board = 'main', repo, liveOf, sync, projectRoot, costMeterAvailable = false }) {
   // Uniform timestamp across snapshot calculation.
   const now = Date.now()
   // Tasks are sorted and grouped on server: repo grouping with active items first.
@@ -384,6 +397,7 @@ export function buildBoard({ store, config, board = 'main', repo, liveOf, sync,
     facets: facetsOf(tasks),
     // Sync telemetry state attached directly to board snapshot.
     sync: sync ?? { state: 'never' },
+    costMeterAvailable: Boolean(costMeterAvailable),
   }
 }
 
@@ -773,12 +787,27 @@ export async function handleCleanupWorktree({
 /**
  * Get working copy diff for task.
  */
-export async function handleTaskDiff({ task, getTaskDiff }) {
+export async function handleTaskDiff({ task, getTaskDiff, getTaskDiffInspector }) {
   if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  if (typeof getTaskDiffInspector === 'function') {
+    const inspectorResult = await getTaskDiffInspector({ worktreePath: task.worktree })
+    return { status: 200, body: inspectorResult }
+  }
   const diffResult = await getTaskDiff({ worktreePath: task.worktree })
   return { status: 200, body: diffResult }
 }
 
+/**
+ * Discard file changes in task worktree (#371).
+ */
+export async function handleTaskDiscard({ task, file, discardTaskFile }) {
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+  if (!file || typeof file !== 'string') return { status: 400, body: { error: 'file-required' } }
+  if (!task.worktree) return { status: 400, body: { error: 'no-worktree' } }
+  const result = await discardTaskFile({ worktreePath: task.worktree, file })
+  return { status: result.success ? 200 : 400, body: result }
+}
+
 /**
  * Get commit list for task.
  */
@@ -1104,4 +1133,75 @@ export async function handleCreateTaskPr({ store, gitea, task, input }) {
   } catch (err) {
     return { status: 502, body: { error: 'gitea-pr-failed', detail: err?.message } }
   }
-}
+}
+/**
+ * Handle interactive live steering (nudge) for an active task agent (#373).
+ *
+ * @param {{
+ *   store: object,
+ *   id: string,
+ *   prompt: string,
+ *   agents?: object,
+ *   createMessage?: Function,
+ *   eventHub?: object,
+ *   now?: number
+ * }} options
+ * @returns {Promise<{ status: number, body: object }>}
+ */
+export async function handleTaskNudge({ store, id, prompt, agents, createMessage, eventHub, now = Date.now() }) {
+  if (!store || !id) return { status: 400, body: { error: 'invalid-parameters' } }
+  const task = store.getTask(id)
+  if (!task) return { status: 404, body: { error: 'task-not-found' } }
+
+  const text = typeof prompt === 'string' ? prompt.trim() : ''
+  if (!text) return { status: 400, body: { error: 'prompt-required' } }
+
+  const sessionId = typeof task.sessionId === 'string' ? task.sessionId : ''
+  if (!sessionId) return { status: 409, body: { error: 'no-session' } }
+
+  let agent
+  try { agent = agents?.get?.(sessionId) } catch { agent = undefined }
+  if (!agent || typeof agent.followup !== 'function') {
+    return { status: 409, body: { error: 'session-not-live' } }
+  }
+
+  const msg = typeof createMessage === 'function'
+    ? createMessage({
+        content: [{ type: 'text', text }],
+        source: { kind: 'dsh-kanban', plugin: 'dsh-kanban', form: 'task-nudge' },
+      })
+    : { content: [{ type: 'text', text }] }
+
+  agent.followup(msg)
+
+  // Append user steering comment to task
+  if (typeof store.addComment === 'function') {
+    store.addComment(id, {
+      author: 'user',
+      role: 'user',
+      text: `[Steering Nudge] ${text}`,
+    })
+  } else if (typeof store.addTaskComment === 'function') {
+    store.addTaskComment(id, {
+      author: 'user',
+      role: 'user',
+      text: `[Steering Nudge] ${text}`,
+    })
+  }
+
+  // Broadcast change via eventHub
+  if (eventHub && typeof eventHub.broadcast === 'function') {
+    eventHub.broadcast('task:change', { id, col: task.col || task.column })
+  }
+
+  return {
+    status: 200,
+    body: {
+      success: true,
+      id,
+      sessionId,
+      prompt: text,
+      nudgedAt: now,
+    },
+  }
+}

package/lib/store.js

@@ -108,6 +108,8 @@ const WRITABLE = [
   'cron', 'nextRunAt', 'lastRunAt', 'progressDump', 'permission', 'reasoningEffort', 'permissionConfirmedAt',
   'runs', 'checklist', 'report', 'comments', 'rejectReason', 'rejectedAt', 'parentId', 'isEpic',
   'workflowRunId', 'workflowStatus', 'permissionConfirmedTier', 'forge', 'queuedRequest',
+  'verificationCommand', 'verificationStatus',
+  'costMetrics', 'costLimitExceeded',
 ]
 
 /** Valid transition sources; unexpected values are rejected to preserve log integrity. */
@@ -161,6 +163,16 @@ function rowToTask(row) {
     reasoningEffort: rest.reasoningEffort ?? '',
     isEpic: isEpic === 1,
     parentId: parentId ?? '',
+    costMetrics: (() => {
+      if (typeof rest.costMetrics === 'string' && rest.costMetrics.trim()) {
+        try {
+          const val = JSON.parse(rest.costMetrics);
+          if (val && typeof val === 'object') return val;
+        } catch {}
+      }
+      return rest.costMetrics && typeof rest.costMetrics === 'object' ? rest.costMetrics : null;
+    })(),
+    costLimitExceeded: rest.costLimitExceeded === 1 || rest.costLimitExceeded === true,
   }
 }
 
@@ -249,6 +261,10 @@ export function openStore({ dir }) {
     ['forge', "TEXT NOT NULL DEFAULT ''"],
     ['permissionConfirmedTier', "TEXT NOT NULL DEFAULT ''"],
     ['queuedRequest', "TEXT NOT NULL DEFAULT ''"],
+    ['verificationCommand', "TEXT NOT NULL DEFAULT ''"],
+    ['verificationStatus', "TEXT NOT NULL DEFAULT ''"],
+    ['costMetrics', "TEXT NOT NULL DEFAULT ''"],
+    ['costLimitExceeded', "INTEGER NOT NULL DEFAULT 0"],
   ]) {
     try { db.exec(`ALTER TABLE tasks ADD COLUMN ${column} ${definition}`) } catch { /* column already exists */ }
   }
@@ -650,6 +666,15 @@ export function openStore({ dir }) {
       })
     },
 
+    appendComment(id, comment) {
+      if (!comment || typeof comment !== 'object') return undefined
+      return this.addComment(id, {
+        author: comment.author || 'user',
+        role: comment.role || 'user',
+        text: comment.text || comment.body || '',
+      })
+    },
+
     updateChecklist(id, items) {
       const task = rowToTask(q.taskById.get(id))
       if (!task) return undefined