@goodandready/dsh-kanban 0.2.19 → 0.2.20

package/lib/launcher.js

@@ -1,16 +1,14 @@
-// Запуск работы по задаче: отдельная сессия агента с выбранной моделью.
+// Task execution launcher: dedicated agent session with chosen model.
 //
-// Плагин НЕ готовит ничего, кроме сессии. Ветку и worktree он не создаёт: по
-// воркфлоу агент сначала делает preflight — смотрит открытые ветки и worktree,
-// проверяет рабочее дерево — и только потом заводит worktree от свежего
-// origin/main. Плагин, создающий ветку заранее, ломает preflight: ветка
-// появится до того, как выяснится, что задачу вообще нельзя начинать.
+// The plugin does not prepare branches or worktrees in advance: the agent conducts
+// preflight first to check existing worktrees and branch status before branching from origin/main.
+// Pre-creating branches would interfere with preflight validation.
 //
-// По той же причине плагин не пишет стартовый комментарий в issue. Его пишет
-// агент после preflight, потому что до preflight ветка и план неизвестны.
+// The agent writes the start comment on the issue after preflight, as branch
+// and plan are determined during preflight.
 //
-// Пакеты ядра здесь не импортируются: идентификатор сессии и сборка сообщения
-// приходят параметрами. Так модуль проверяется без харнесса и без сети.
+// Core packages are not imported directly; session ID and message factory
+// are passed as parameters to support unit testing without harness runtime.
 
 import { isAbsolute, join, resolve, sep } from 'node:path'
 import { randomUUID } from 'node:crypto'
@@ -20,34 +18,30 @@ import { formatHandoverPreamble, parseProgressDump } from './progress-dump.js'
 export const PERMISSION_RANKS = { 'read-only': 0, 'workspace-write': 1, 'danger-full-access': 2 }
 
 /**
- * Хвост своей задачи — УСЛОВИЕ, а не приказ.
+ * Tail instructions for local board tasks.
  *
- * На доску вешают что угодно: «прибраться в логах», «найди мне вот такую
- * информацию». Распоряжение делать preflight веток и заводить worktree для
- * такой задачи бессмысленно — агент честно уходил искать репозитории и
- * перечислять worktree вместо того, чтобы заняться написанным.
- *
- * Поэтому решает агент по содержанию задачи, а не доска заранее.
+ * Local tasks cover ad-hoc activities where repo preflight and branch creation
+ * may not apply. The agent evaluates task context rather than forcing repo workflows.
  */
-const OWN_TAIL = 'Если задача окажется про код проекта — придерживайся его воркфлоу; '
-  + 'если нет — просто сделай, что написано выше.'
+const OWN_TAIL = 'If the task is about project code, follow its workflow; '
+  + 'if not, just perform what is written above.'
 
-/** Хвост про воркфлоу — ТОЛЬКО для задач, за которыми стоит issue. */
+/** Tail instructions for workflow tasks backed by a Gitea issue. */
 const WORKFLOW_TAIL = [
-  'Работай по действующему воркфлоу проекта: сначала preflight открытых веток и',
-  'worktree, затем worktree от свежего origin/main, стартовый комментарий в issue',
-  'с планом и проверками, дальше реализация.',
+  'Follow active project workflow: first preflight open branches and',
+  'worktrees, then worktree from fresh origin/main, initial issue comment',
+  'with plan and checks, then implementation.',
 ].join('\n')
 
 /**
- * Первое сообщение агенту.
+ * Initial message prompt for a task.
  *
- * Сообщение НЕ содержит указаний создать ветку с конкретным именем: имя ветки
- * выбирает агент после preflight.
+ * Does not instruct the agent to use a specific branch name; the agent selects
+ * branch naming following project workflow after preflight.
  *
- * @param {object} task задача доски
- * @param {object} config настройки плагина
- * @returns {string} текст сообщения
+ * @param {object} task board task
+ * @param {object} config plugin settings
+ * @returns {string} prompt message body
  */
 export function buildStartMessage(task, config) {
   const vars = {
@@ -63,22 +57,22 @@ export function buildStartMessage(task, config) {
   const custom = typeof config?.startPrompt === 'string' ? config.startPrompt.trim() : ''
   if (custom !== '') return joinBlocks([substitute(custom, vars), note])
 
-  // Задача из issue и своя задача — разные сообщения, а не одно с пропусками.
+  // Issue tasks and local board tasks use distinct prompt layouts.
   const fromIssue = vars.repo !== '' && vars.issueNumber !== ''
   const head = fromIssue
-    ? `Задача ${vars.repo}#${vars.issueNumber}: ${vars.title}`
-    : `Задача: ${vars.title}`
+    ? `Task ${vars.repo}#${vars.issueNumber}: ${vars.title}`
+    : `Task: ${vars.title}`
 
   return joinBlocks([
     head,
     vars.body,
-    fromIssue && vars.issueUrl !== '' ? `Ссылка: ${vars.issueUrl}` : '',
+    fromIssue && vars.issueUrl !== '' ? `Link: ${vars.issueUrl}` : '',
     fromIssue ? WORKFLOW_TAIL : OWN_TAIL,
     note,
   ])
 }
 
-/** Склеить непустые куски пустой строкой между ними. */
+/** Join non-empty blocks with double newlines. */
 function joinBlocks(parts) {
   return parts.map((p) => String(p ?? '').trim()).filter(Boolean).join('\n\n')
 }
@@ -92,23 +86,18 @@ function substitute(template, vars) {
 }
 
 /**
- * Рабочая папка сессии — КОРНЕВОЙ checkout проекта, не worktree.
- *
- * Корневой checkout по воркфлоу только для чтения, и это ровно то место, где
- * положено начинать: preflight читает состояние репозитория. Worktree заведёт
- * агент.
+ * Working directory for session — root checkout of the project, not a worktree.
  *
- * Имя репозитория приходит из данных Gitea, а не из кода, поэтому выход за
- * пределы корня отвергается: иначе задача с подделанным именем увела бы сессию
- * в произвольный каталог.
+ * Root checkout is read-only per workflow guidelines; preflight checks run here.
+ * Path traversal outside project root is rejected.
  *
- * @throws если корень не абсолютный либо имя репозитория выводит за его пределы
+ * @throws if root is not absolute or repository path escapes project root fence
  */
 export function resolveCwd(task, config, cwdOf = () => process.cwd()) {
   const root = typeof config?.defaultProjectRoot === 'string' && config.defaultProjectRoot.trim() !== ''
     ? config.defaultProjectRoot.trim()
     : cwdOf()
-  if (!isAbsolute(root)) throw new Error('корень проектов должен быть абсолютным путём')
+  if (!isAbsolute(root)) throw new Error('project root must be an absolute path')
 
   const repo = typeof task?.repo === 'string' ? task.repo.trim() : ''
   if (repo === '') return root
@@ -117,27 +106,20 @@ export function resolveCwd(task, config, cwdOf = () => process.cwd()) {
   const fence = resolve(root)
   const fenceSep = fence.endsWith(sep) || fence.endsWith('/') ? fence : fence + sep
   if (target !== fence && !target.startsWith(fenceSep) && !target.startsWith(fence.endsWith('/') ? fence : fence + '/')) {
-    throw new Error('имя репозитория выводит за пределы корня проектов')
+    throw new Error('repository name escapes project root')
   }
   return target
 }
 
 /**
- * Взять агента задачи: живого, возобновлённого или нового.
- *
- * Правило владельца — **одна задача, один чат**, сколько бы этапов в ней ни
- * было. Поэтому новую сессию поднимаем только когда прежней взять неоткуда.
- *
- * Возобновление не проверяем заранее отдельным вопросом «сохранена ли сессия»:
- * такого вопроса у ядра нет, а `resume` сам скажет отказом. Пробуем и ловим.
+ * Retrieve agent for task: active, resumed, or newly spawned.
  *
- * @returns {{agent: object, sessionId: string, mode: 'opened'|'resumed'|'created'}}
+ * Enforces one chat session per task. Reuses existing session when possible.
  */
 export function applyPermission({ permissions, agent, name }) {
   if (typeof name !== 'string' || name === '') return { skipped: 'not-picked' }
-  // Служба необязательна: развёртывание может её не собирать. Но если человек
-  // выбрал уровень доступа, а поставить его нечем — запускать нельзя: сессия
-  // пошла бы с правами по умолчанию, то есть, возможно, БОЛЬШИМИ, чем просили.
+  // Permission service is optional. If permission level is selected but service
+  // is unavailable, execution fails rather than running with broader default permissions.
   if (permissions === undefined || typeof permissions.set !== 'function') {
     return { error: 'permission-unavailable' }
   }
@@ -156,17 +138,17 @@ export async function obtainAgent({
   const known = typeof task?.sessionId === 'string' && task.sessionId !== '' ? task.sessionId : undefined
 
   if (known !== undefined) {
-    // Живой агент — просто берём его.
+    // Live agent — reuse active session.
     let live
     try { live = agents.get(known) } catch { live = undefined }
     if (live !== undefined) return { agent: live, sessionId: known, mode: 'opened' }
 
-    // Сессия выгружена, но могла сохраниться.
+    // Session suspended; attempt resume.
     try {
       const handle = await agents.resume({ resumeSessionId: known, agentOptions: { provider, model } })
       return { agent: handle.agent, sessionId: handle.agent.session.id, mode: 'resumed' }
     } catch (error) {
-      logger?.warn?.(`dsh-kanban: сессия ${known} не возобновилась: ${error?.message}`)
+      logger?.warn?.(`dsh-kanban: session ${known} resume failed: ${error?.message}`)
     }
   }
 
@@ -200,11 +182,11 @@ export async function obtainAgent({
         }
       }
     } catch (err) {
-      logger?.warn?.(`dsh-kanban: не удалось создать worktree для ${task.id}: ${err.message}`)
+      logger?.warn?.(`dsh-kanban: failed to create worktree for ${task.id}: ${err.message}`)
     }
   }
 
-  // meta.cwd сохраняет projectRoot, чтобы DSH группировал сессию внутри проекта (#227)
+  // meta.cwd preserves projectRoot so DSH groups session under the project (#227)
   const meta = { cwd: projectRoot, projectRoot }
   if (worktreePath) meta.worktreePath = worktreePath
   if (branchName) meta.branch = branchName
@@ -213,17 +195,16 @@ export async function obtainAgent({
 
   const handle = await agents.create({
     sessionId: mintSessionId(),
-    // Профиль — факт создания сессии: у идущей его не сменить, поэтому он
-    // едет здесь, а не отдельным вызовом после.
+    // Profile is set during session creation.
     meta,
     agentOptions: { provider, model },
   })
   const access = applyPermission({ permissions, agent: handle.agent, name: permission })
   if (access.error !== undefined) {
-    // Сессия уже поднята, но работать в ней с чужими правами не дадим.
-    try { handle.dispose?.() } catch { /* уборка не важнее отказа */ }
-    logger?.warn?.(`dsh-kanban: уровень доступа не поставлен: ${access.reason ?? access.error}`)
-    const error = new Error('уровень доступа не поставлен')
+    // Session already initialized; preserve configured permissions.
+    try { handle.dispose?.() } catch { /* cleanup is secondary to rejection */ }
+    logger?.warn?.(`dsh-kanban: access tier not set: ${access.reason ?? access.error}`)
+    const error = new Error('access tier not set')
     error.key = access.error
     error.status = 409
     throw error
@@ -240,40 +221,30 @@ export async function obtainAgent({
 }
 
 /**
- * Запустить или продолжить работу по задаче.
+ * Launch or resume task execution.
  *
- * Порядок важен: сначала берём агента, дожидаемся простоя, отправляем
- * сообщение и только потом пишем в хранилище. Запись до запуска оставила бы
- * задачу в «В работе» без сессии, если запуск упадёт.
+ * Order of operations: acquire agent, wait for idle, send prompt, then update store.
+ * Prevents leaving orphaned in-progress cards if agent launch fails.
+ * Column moves from backlog to in-progress only on initial launch. Resumed tasks
+ * retain their current column (e.g. review).
  *
- * Колонку двигаем ТОЛЬКО при первом запуске из бэклога. Задача в «Ревью», по
- * которой нажали «Продолжить», обязана остаться в «Ревью»: продолжение — это
- * не откат к началу.
- *
- * @param {string} [text] сообщение человека; пусто — встроенная заготовка
+ * @param {string} [text] user message; defaults to standard template if empty
  * @returns {{sessionId: string, mode: string, task: object}}
  */
 /**
- * Что случилось при попытке продолжить работу.
- *
- * «Продолжил» и «начал заново» — разные вещи, и человек обязан видеть, какая
- * из них произошла: в первом случае переписка на месте, во втором её больше
- * нет.
+ * Mode explanation for task continuation: opened, resumed, or created.
  *
- * @returns {'opened'|'resumed'|'created'} как в obtainAgent
+ * @returns {'opened'|'resumed'|'created'} matching obtainAgent mode
  */
 export function revivalKind(mode) {
   return mode === 'opened' || mode === 'resumed' ? mode : 'created'
 }
 
 /**
- * Взять задачу на себя при запуске.
+ * Claim task upon launch if currently unassigned.
+ * Does not overwrite existing assignee.
  *
- * Запустить работу и оставить задачу ничьей — значит показать её свободной,
- * когда над ней уже работают. Чужое назначение не трогаем: задачу могли отдать
- * другому осознанно.
- *
- * @returns {string} логин, если назначение случилось; иначе пустая строка
+ * @returns {string} assignee login if claimed; otherwise empty string
  */
 export function claimOnStart({ store, task, login }) {
   const who = typeof login === 'string' ? login.trim() : ''
@@ -285,7 +256,7 @@ export function claimOnStart({ store, task, login }) {
     fromCol: task.column,
     toCol: task.column,
     source: 'manual',
-    detail: `ответственный: ${who} (взял при запуске)`,
+    detail: `assigned: ${who} (claimed on launch)`,
   })
   return who
 }
@@ -296,11 +267,11 @@ export async function runTask({
   agentPreset, permission, permissions, claimAs,
   gitRunner, workspaceRegistry, resume = false,
 }) {
-  // Проверка лимита параллелизма (#214)
+  // Concurrency limit check (#214)
   const maxConcurrent = typeof config?.maxConcurrentSessions === 'number' ? config.maxConcurrentSessions : 3
   if (maxConcurrent > 0) {
     const activeCount = countActiveSessions({ store, agents })
-    // Если задача уже в очереди или это новый запуск, и слоты исчерпаны
+    // Check active session slots if task is not already running
     const isAlreadyRunning = task.sessionId && agents?.get?.(task.sessionId)?.status === 'running'
     if (!isAlreadyRunning && activeCount >= maxConcurrent) {
       const now = Date.now()
@@ -310,7 +281,7 @@ export async function runTask({
         fromCol: task.column,
         toCol: task.column,
         source: 'session',
-        detail: `превышен лимит параллельных сессий (${activeCount}/${maxConcurrent}), задача поставлена в очередь`,
+        detail: `concurrent session limit reached (${activeCount}/${maxConcurrent}), task queued`,
       })
       return { mode: 'queued', queued: true, taskId: task.id, activeCount, maxConcurrent }
     }
@@ -320,7 +291,7 @@ export async function runTask({
     const defaultPerm = config?.sessionDefaultPermission || 'read-only'
     if ((PERMISSION_RANKS[perm] ?? 0) > (PERMISSION_RANKS[defaultPerm] ?? 0)) {
       if (!task.permissionConfirmedAt || task.permissionConfirmedAt === 0) {
-        const err = new Error('Требуется подтверждение прав')
+        const err = new Error('Permission confirmation required')
         err.key = 'permission-unconfirmed'
         err.status = 403
         throw err
@@ -337,7 +308,7 @@ export async function runTask({
     store.updateTask(task.id, { queuedAt: 0 })
   }
 
-  // Фиксируем запуск в истории задачи
+  // Record run in task execution history
   if (typeof store.recordTaskRun === 'function') {
     store.recordTaskRun(task.id, {
       id: randomUUID(),
@@ -350,8 +321,7 @@ export async function runTask({
 
   await taken.agent.whenIdle()
   taken.agent.followup(createMessage({
-    // Содержимое — МАССИВ блоков, а не строка: ядро перебирает его как список
-    // (`content.some(...)`), и строка роняет ход целиком.
+    // Content must be an array of blocks for core message schema.
     content: [{ type: 'text', text: messageFor(task, config, text, { resume, mode: taken.mode }) }],
     source: { kind: 'dsh-kanban', plugin: 'dsh-kanban', form: resume ? 'task-resume' : 'task-start' },
   }))
@@ -367,8 +337,7 @@ export async function runTask({
     ...(taken.workspaceId ? { workspaceId: taken.workspaceId } : {}),
   }
   store.updateTask(task.id, patch)
-  // Запустил — значит отвечаешь: свободная задача становится твоей, чужая
-  // остаётся чужой.
+  // Claim task on launch if unassigned.
   claimOnStart({ store, task: before, login: claimAs })
 
   if (resume) {
@@ -377,30 +346,29 @@ export async function runTask({
       fromCol: before.column,
       toCol: before.column,
       source: 'session',
-      detail: `продолжение работы над задачей (сессия ${taken.sessionId})`,
+      detail: `continuing task execution (session ${taken.sessionId})`,
     })
   }
 
-  // Изоляция сессии в отдельном воркдереве фиксируется в журнале.
+  // Record worktree isolation transition in task log.
   if (taken.worktreeCreated) {
     store.addTransition({
       taskId: task.id,
       fromCol: before.column,
       toCol: before.column,
       source: 'session',
-      detail: `изоляция: создано воркдерево ${taken.worktree} (${taken.branch})`,
+      detail: `isolation: created worktree ${taken.worktree} (${taken.branch})`,
     })
   }
 
-  // Подмена чата не должна быть молчаливой: человек вернётся к задаче и не
-  // поймёт, куда делась переписка.
+  // Log notice if unable to resume previous session and new session had to be spawned.
   if (taken.mode === 'created' && before.sessionId) {
     store.addTransition({
       taskId: task.id,
       fromCol: before.column,
       toCol: before.column,
       source: 'session',
-      detail: `прежняя сессия не возобновилась, поднята новая: ${taken.sessionId}`,
+      detail: `previous session not resumed, spawned new: ${taken.sessionId}`,
     })
   }
 
@@ -412,33 +380,33 @@ export async function runTask({
       fromCol: before.column,
       toCol: 'in-progress',
       source: 'session',
-      detail: `сессия ${taken.sessionId}, модель ${model}`,
+      detail: `session ${taken.sessionId}, model ${model}`,
     })
   }
 
   return { sessionId: taken.sessionId, mode: revivalKind(taken.mode), task: current }
 }
 
-/** Текст сообщения: человеческий, если он есть, иначе встроенная заготовка. */
+/** Build prompt text: custom user message if provided, otherwise standard template. */
 export function messageFor(task, config, text, options = {}) {
   const own = typeof text === 'string' ? text.trim() : ''
   let base = own !== '' ? own : buildStartMessage(task, config)
   let resumePreamble = ''
   if (options.resume || options.mode === 'resumed') {
-    const wt = task?.worktree ? ` в существующем воркдереве ${task.worktree}` : ''
-    const br = task?.branch ? ` на ветке ${task.branch}` : ''
-    resumePreamble = `### ↻ Режим продолжения работы над задачей\nРабота продолжается${wt}${br}. Сохраняй существующие изменения и продолжай выполнение с текущего состояния.\n\n`
+    const wt = task?.worktree ? ` in existing worktree ${task.worktree}` : ''
+    const br = task?.branch ? ` on branch ${task.branch}` : ''
+    resumePreamble = `### ↻ Resumed task execution\nContinuing work${wt}${br}. Preserve existing changes and proceed from the current state.\n\n`
   }
   let qualityNotes = ''
   if (task?.rejectReason) {
-    qualityNotes += `### ⚠️ Внимание: Задача возвращена на доработку\nЗамечания к приёмке (причина возврата):\n${task.rejectReason}\n\n`
+    qualityNotes += `### ⚠️ Notice: Task returned for rework\nReview notes (rejection reason):\n${task.rejectReason}\n\n`
   }
   if (Array.isArray(task?.checklist) && task.checklist.length > 0) {
     const uncompleted = task.checklist.filter((i) => i.required !== false && !i.completed)
     if (uncompleted.length > 0) {
-      qualityNotes += `### Обязательные критерии готовности (DoD):\n`
+      qualityNotes += `### Definition of Done (DoD):\n`
         + uncompleted.map((item, idx) => `${idx + 1}. [ ] ${item.text}`).join('\n')
-        + `\nДля фиксации выполнения используй инструмент board_checklist(item, evidence).\n\n`
+        + `\nUse the board_checklist(item, evidence) tool to record completed items.\n\n`
     }
   }
   if (qualityNotes) {
@@ -463,9 +431,7 @@ export function messageFor(task, config, text, options = {}) {
 }
 
 /**
- * Провайдер и модель для запуска: сначала выбор человека, затем модель по
- * умолчанию из харнесса. Если не выбрано ни там, ни там — внятный отказ, а не
- * падение.
+ * Resolve provider and model for launch: user choice first, then harness default.
  */
 export function resolveModel({ requested, fallback }) {
   const provider = requested?.provider || fallback?.provider
@@ -475,32 +441,16 @@ export function resolveModel({ requested, fallback }) {
 }
 
 /**
- * Сообщение об одной задаче пачки.
- *
- * Номер и общее число — не украшение. По воркфлоу агент после задачи делает
- * cleanup: удаляет ветку, worktree, закрывает issue. Получив первую из пяти и
- * не зная про остальные, он честно объявит работу законченной и приберёт за
- * собой — а следующая придёт в уже прибранный чат.
- *
- * Номер превращает пять отдельных работ в одну из пяти частей.
+ * Message prompt for an individual task in a batch execution.
  */
 export function buildQueuedMessage(task, config, at, total) {
   const body = buildStartMessage(task, config)
-  return total > 1 ? joinBlocks([`Задача ${at} из ${total}.`, body]) : body
+  return total > 1 ? joinBlocks([`Task ${at} of ${total}.`, body]) : body
 }
 
 /**
- * Запустить пачку задач ОДНОЙ сессией, отдавая их по очереди.
- *
- * «Разом» не бывает: пачка всегда идёт по одной. Решение владельца, и правило
- * лучше выбора — одним переключателем меньше и одним путём в коде меньше.
- *
- * В работу уезжает ТОЛЬКО первая. Остальные остаются на своих местах с
- * отметкой очереди: десять карточек в «В работе», из которых делается одна, —
- * это ложь, и предел колонки от неё теряет смысл.
- *
- * Порядок важен: сперва агент и сообщения, потом хранилище. Запись до запуска
- * оставила бы карточки с идентификатором сессии, которой нет.
+ * Launch a batch of tasks within a single session, processed sequentially.
+ * Only the first task transitions to 'in-progress'; remaining tasks are queued.
  */
 export async function runBatch({
   agents, store, tasks, config, provider, model,
@@ -532,26 +482,23 @@ export async function runBatch({
   list.forEach((task, at) => {
     const before = store.getTask(task.id)
     if (before === undefined) return
-    // Первая — в работу; остальные ждут очереди там, где лежат. Отметка
-    // постановки идёт с шагом, чтобы порядок очереди совпал с порядком выбора
-    // даже когда всё случилось в одну миллисекунду.
+    // First task moves to in-progress; remainder are queued with staggered queuedAt.
     const patch = { sessionId: taken.sessionId, provider, model, queuedAt: at === 0 ? 0 : now + at }
     store.updateTask(task.id, patch)
-    // Пачку берёт на себя тот, кто её запустил: пять карточек в работе без
-    // ответственного выглядят свободными.
+    // Claim all tasks in batch under launching user.
     claimOnStart({ store, task: before, login: claimAs })
     if (at === 0 && before.column === 'backlog') {
       store.moveTask(task.id, { column: 'in-progress' })
       store.addTransition({
         taskId: task.id, fromCol: before.column, toCol: 'in-progress', source: 'session',
         detail: list.length > 1
-          ? `сессия ${taken.sessionId} на ${list.length} задач, модель ${model}`
-          : `сессия ${taken.sessionId}, модель ${model}`,
+          ? `session ${taken.sessionId} for ${list.length} tasks, model ${model}`
+          : `session ${taken.sessionId}, model ${model}`,
       })
     } else if (at > 0) {
       store.addTransition({
         taskId: task.id, fromCol: before.column, toCol: before.column, source: 'session',
-        detail: `в очереди сессии ${taken.sessionId}, ${at + 1} из ${list.length}`,
+        detail: `in session queue ${taken.sessionId}, ${at + 1} of ${list.length}`,
       })
     }
     started.push(task.id)
@@ -561,11 +508,7 @@ export async function runBatch({
 }
 
 /**
- * Поставить задачу в очередь уже идущей сессии.
- *
- * Своей очереди не заводим: у ядра она есть. `followup` кладёт сообщение, а
- * агент берёт его на ближайшей границе шага — то есть закончив текущее.
- * Вторая очередь рядом с настоящей разошлась бы с ней при первой же заминке.
+ * Queue a task to an active session using core followup queue.
  */
 export async function queueTask({
   agents, store, task, sessionId, config, createMessage, text, now = Date.now(),
@@ -576,8 +519,7 @@ export async function queueTask({
 
   let agent
   try { agent = agents.get(id) } catch { agent = undefined }
-  // Мёртвой сессии ставить в очередь нечего: сообщение исчезнет, а карточка
-  // останется привязанной к тому, чего нет.
+  // Reject queueing to dead or non-existent session.
   if (agent === undefined) return { error: 'session-not-live', status: 409 }
 
   const own = typeof text === 'string' ? text.trim() : ''
@@ -590,20 +532,14 @@ export async function queueTask({
   store.updateTask(task.id, { sessionId: id, queuedAt: now })
   store.addTransition({
     taskId: task.id, fromCol: before.column, toCol: before.column, source: 'session',
-    detail: `поставлена в очередь сессии ${id}`,
+    detail: `queued for session ${id}`,
   })
   return { task: store.getTask(task.id), sessionId: id }
 }
 
 /**
- * Снять задачу с очереди.
- *
- * Обязательная пара к постановке: если поставить можно, а передумать нельзя,
- * человек перестанет пользоваться и постановкой.
- *
- * Сообщение из очереди ядра не выдернуть — оно уже отдано. Поэтому снимаем
- * привязку и честно говорим об этом в журнале: агент может дойти до задачи и
- * увидеть карточку, которая его больше не ждёт.
+ * Remove task from queue.
+ * Clears queue association in store and logs note that message was already sent to agent.
  */
 export function unqueueTask({ store, task }) {
   if (task === undefined) return { error: 'task-not-found', status: 404 }
@@ -613,16 +549,13 @@ export function unqueueTask({ store, task }) {
   store.updateTask(task.id, { queuedAt: 0, sessionId: null })
   store.addTransition({
     taskId: task.id, fromCol: task.column, toCol: task.column, source: 'manual',
-    detail: 'снята с очереди; сообщение агенту уже отдано и отозвать его нечем',
+    detail: 'removed from queue; message already sent to agent',
   })
   return { task: store.getTask(task.id) }
 }
 
 /**
- * Живые сессии доски: куда вообще можно поставить задачу.
- *
- * Сессия без живого агента в список не попадает — предлагать её значило бы
- * предлагать очередь, из которой никто ничего не возьмёт.
+ * Query active sessions eligible for queueing.
  */
 export function countActiveSessions({ store, agents }) {
   const sessions = liveSessions({ store, agents })
@@ -638,7 +571,7 @@ export function liveSessions({ store, agents }) {
     let live
     try { live = agents.get(id) } catch { live = undefined }
     if (live === undefined) continue
-    // Исключаем дочерние сессии субагентов (#215)
+    // Exclude child subagent sessions (#215)
     if (live.origin === 'subagent' || live.parentId !== undefined || live.meta?.origin === 'subagent' || live.isSubagent) {
       continue
     }
@@ -652,7 +585,7 @@ export function liveSessions({ store, agents }) {
 }
 
 /**
- * Автоматический запуск следующей задачи из очереди при освобождении слота (#214).
+ * Auto-dispatch next queued task when a concurrency slot opens (#214).
  */
 export async function dispatchNextQueuedTask({
   agents, store, config, mintSessionId, createMessage, cwdOf, logger,
@@ -688,7 +621,7 @@ export async function dispatchNextQueuedTask({
       gitRunner,
     })
   } catch (err) {
-    logger?.warn?.(`dsh-kanban: не удалось запустить задачу ${nextTask.id} из очереди: ${err?.message}`)
+    logger?.warn?.(`dsh-kanban: failed to start queued task ${nextTask.id}: ${err?.message}`)
     return null
   }
 }