mandrel 1.94.0 → 2.1.0

package/.agents/scripts/lib/orchestration/epic-runner/progress-signals/maintainability-drift.js

@@ -1,117 +0,0 @@
-import nodeFs from 'node:fs';
-import path from 'node:path';
-
-import { calculateForSource } from '../../../maintainability-engine.js';
-import { formatNumber } from './_bullet-format.js';
-import {
-  createDriftDetector,
-  walkComponentRegressions,
-} from './component-drift.js';
-
-const DEFAULT_THRESHOLD = 2.0;
-// Distinct from the canonical ratchet baseline at `baselines/maintainability.json`
-// (Epic #730 Story 5.5) — this file is a per-wave drift SNAPSHOT, not the
-// committed score baseline. Filename intentionally differs so a repo-wide
-// grep for the canonical baseline no longer hits the snapshot.
-const BASELINE_FILENAME = 'wave-mi-snapshot.json';
-
-/**
- * Detect per-component maintainability regressions from a baseline rollup
- * against the gate's configured floors. Pure — the caller loads the
- * baseline via `lib/baselines/reader.js#load('maintainability')` and passes
- * the resulting `{ rollup }` plus the gate config block.
- *
- * Bullet shape (Task #1919, Epic #1786):
- *
- *   📉 maintainability: <component> <axis> <value> < floor <floor>
- *
- * Maintainability is "higher is better" — every axis breach reports when
- * `value < floor`. Component-scoped breaches do NOT trigger a `*` bullet
- * unless `*` itself breaches. The walk itself is the shared
- * `component-drift.js` helper (Story #3984).
- *
- * @param {{
- *   rollup?: Record<string, Record<string, number>>,
- *   gateConfig?: { floors?: Record<string, Record<string, number>> } & object,
- * }} params
- * @returns {string[]}
- */
-export function detectComponentRegressions(params = {}) {
-  return walkComponentRegressions(params, {
-    isBreach: (value, target) => value < target,
-    formatBullet: (name, axis, value, target) =>
-      `📉 maintainability: ${name} ${axis} ${formatNumber(value)} < floor ${formatNumber(target)}`,
-  });
-}
-
-/**
- * Detects per-file maintainability drop versus a wave-start baseline.
- *
- * Usage:
- *   const detector = createMaintainabilityDriftDetector({ cwd, files });
- *   detector.captureBaseline();   // call once at wave-start
- *   await detector.detect(rows);  // call each progress fire
- *
- * A baseline is a map of file -> score, persisted to
- * `<cwd>/<baselineDir>/wave-mi-snapshot.json` so that a resumed epic
- * run can re-read the snapshot from the previous wave rather than lose the
- * anchor. Any file whose score has dropped by >= `threshold` since baseline
- * is surfaced as a bullet:
- *
- *   📉 Maintainability drift: <file> -<n.nn> vs wave-start baseline
- *
- * Errors while reading/scoring individual files are swallowed — a single
- * bad file must not take the progress reporter down.
- *
- * @param {{
- *   cwd?: string,
- *   files?: string[],               // files to watch; repo-relative paths
- *   fs?: { readFileSync: Function, writeFileSync?: Function, mkdirSync?: Function, existsSync?: Function },
- *   calculate?: (source: string) => number,
- *   threshold?: number,             // drop (baseline - current) that trips a bullet
- *   baselineDir?: string,           // directory (under cwd) to persist snapshot
- * }} [opts]
- */
-export function createMaintainabilityDriftDetector(opts = {}) {
-  const fs = opts.fs ?? nodeFs;
-  const cwd = opts.cwd ?? process.cwd();
-  const calculate = opts.calculate ?? calculateForSource;
-  const threshold = Number.isFinite(opts.threshold)
-    ? opts.threshold
-    : DEFAULT_THRESHOLD;
-
-  function scoreFile(relPath) {
-    try {
-      const abs = path.join(cwd, relPath);
-      const src = fs.readFileSync(abs, 'utf-8');
-      const score = calculate(src);
-      return Number.isFinite(score) ? score : null;
-    } catch {
-      return null;
-    }
-  }
-
-  return createDriftDetector({
-    fs,
-    cwd,
-    files: opts.files,
-    baselineDir: opts.baselineDir,
-    baselineFilename: BASELINE_FILENAME,
-    scoreFile,
-    captureScore: (score) => score,
-    async detect({ baseline, scoreFile: score }) {
-      const bullets = [];
-      for (const [relPath, baseScore] of Object.entries(baseline)) {
-        const current = score(relPath);
-        if (current == null) continue;
-        const drop = baseScore - current;
-        if (drop >= threshold) {
-          bullets.push(
-            `📉 Maintainability drift: ${relPath} -${drop.toFixed(2)} vs wave-start baseline`,
-          );
-        }
-      }
-      return bullets;
-    },
-  });
-}

package/.agents/scripts/lib/orchestration/epic-runner/progress-signals/stalled-worktree.js

@@ -1,37 +0,0 @@
-import nodeFs from 'node:fs';
-import path from 'node:path';
-
-/**
- * Detects "worktree residue" — stories that the ticket graph reports as done,
- * but whose `.worktrees/story-<id>/` directory is still on disk. This usually
- * means story-close failed to reap the worktree (see the Windows
- * partial-reap failure mode in friction memory), and a future run of the
- * same story id would collide with the stale directory.
- *
- * The detector is pure (aside from fs reads) and accepts an fs adapter so the
- * unit test can drive present/absent cases without touching disk.
- *
- * @param {{
- *   fs?: { existsSync: (p: string) => boolean },
- *   cwd?: string,
- * }} [opts]
- * @returns {(rows: Array<{id:number|string, state:string}>) => Promise<string[]>}
- */
-export function createStalledWorktreeDetector(opts = {}) {
-  const fs = opts.fs ?? nodeFs;
-  const cwd = opts.cwd ?? process.cwd();
-  return async function detect(rows = []) {
-    const bullets = [];
-    for (const row of rows) {
-      if (row?.state !== 'done') continue;
-      const relPath = `.worktrees/story-${row.id}`;
-      const absPath = path.join(cwd, relPath);
-      if (fs.existsSync(absPath)) {
-        bullets.push(
-          `⚠️ Worktree residue: #${row.id} marked done but .worktrees/story-${row.id}/ still present`,
-        );
-      }
-    }
-    return bullets;
-  };
-}

package/.agents/scripts/lib/orchestration/epic-runner/story-launcher.js

@@ -1,127 +0,0 @@
-/**
- * StoryLauncher — produces the per-wave dispatch plan and (optionally)
- * delegates execution to an injected `dispatch` adapter.
- *
- * After Story #908, in-session Agent-tool fan-out replaces the subprocess
- * spawn pipeline. The launcher's primary responsibility is `planWave(stories)`:
- * given a wave's Story tickets it returns a stable list of
- * `{ storyId, worktree }` entries. The `/deliver` skill consumes that
- * list (one wave at a time) to format one assistant turn containing N
- * parallel `Agent` tool calls (subagent_type `general-purpose`), each of
- * which drives `/deliver <storyId>` for one Story.
- *
- * `launchWave(stories)` is a convenience for callers that already hold a
- * concrete dispatch adapter (tests, future programmatic harnesses). It calls
- * `planWave` and forwards the plan to `dispatch({ plan, concurrencyCap, signal })`,
- * returning the adapter's result list. The CLI does not provide a default
- * dispatch adapter — invoking the engine without one is an explicit error.
- */
-
-const DEFAULT_TIMEOUT_MS = 6 * 60 * 60 * 1000;
-
-export class StoryLauncher {
-  /**
-   * @param {{
-   *   ctx?: { dispatch?: Function, concurrencyCap?: number, worktreeResolver?: (storyId: number) => string, logger?: object },
-   *   concurrencyCap?: number,
-   *   dispatch?: (args: { plan: Array<{ storyId: number, worktree?: string }>, concurrencyCap: number, signal?: AbortSignal }) => Promise<Array<{ storyId: number, status: string, detail?: string }>>,
-   *   worktreeResolver?: (storyId: number) => string,
-   *   timeoutMs?: number,
-   *   logger?: { info: Function, warn: Function, error: Function }
-   * }} opts
-   */
-  constructor(opts = {}) {
-    const ctx = opts?.ctx;
-    const dispatch = opts?.dispatch ?? ctx?.dispatch ?? null;
-    const concurrencyCap = opts?.concurrencyCap ?? ctx?.concurrencyCap;
-    if (!Number.isInteger(concurrencyCap) || concurrencyCap < 1) {
-      throw new RangeError('concurrencyCap must be a positive integer');
-    }
-    this.concurrencyCap = concurrencyCap;
-    this.dispatch = dispatch;
-    this.worktreeResolver = opts?.worktreeResolver ?? ctx?.worktreeResolver;
-    this.timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.logger = opts?.logger ?? ctx?.logger ?? console;
-  }
-
-  /**
-   * Produce the dispatch plan for a wave. Pure: no side effects, no IO. The
-   * caller (the `/deliver` skill's wave loop, or `launchWave` below)
-   * decides what to do with the plan.
-   *
-   * @param {Array<number|{id?:number,storyId?:number,number?:number}>} stories
-   * @returns {Array<{ storyId: number, worktree?: string }>}
-   */
-  planWave(stories) {
-    return (stories ?? []).map((s) => {
-      const storyId =
-        typeof s === 'object' && s !== null
-          ? (s.id ?? s.storyId ?? s.number)
-          : s;
-      const id = Number(storyId);
-      return {
-        storyId: id,
-        worktree: this.worktreeResolver?.(id),
-      };
-    });
-  }
-
-  /**
-   * Plan + dispatch the wave through the injected adapter. Returns one result
-   * entry per input Story preserving input order. Throws when no dispatch
-   * adapter was injected — the engine is no longer callable without one.
-   *
-   * @param {object[]} stories
-   * @param {AbortSignal} [signal]
-   * @returns {Promise<Array<{ storyId: number, status: string, detail?: string }>>}
-   */
-  async launchWave(stories, signal) {
-    if (typeof this.dispatch !== 'function') {
-      throw new TypeError(
-        'StoryLauncher.launchWave requires a dispatch adapter (in-session Agent-tool fan-out is the responsibility of the /deliver skill).',
-      );
-    }
-    const plan = this.planWave(stories);
-    if (plan.length === 0) return [];
-
-    const controller = new AbortController();
-    const timer = setTimeout(
-      () =>
-        controller.abort(new Error(`wave timed out after ${this.timeoutMs}ms`)),
-      this.timeoutMs,
-    );
-    const onParentAbort = () => controller.abort(signal?.reason);
-    signal?.addEventListener?.('abort', onParentAbort, { once: true });
-    try {
-      const results = await this.dispatch({
-        plan,
-        concurrencyCap: this.concurrencyCap,
-        signal: controller.signal,
-      });
-      return this.#alignResults(plan, results);
-    } catch (err) {
-      return plan.map((p) => ({
-        storyId: p.storyId,
-        status: 'failed',
-        detail: err?.message ?? String(err),
-      }));
-    } finally {
-      clearTimeout(timer);
-      signal?.removeEventListener?.('abort', onParentAbort);
-    }
-  }
-
-  #alignResults(plan, results) {
-    const list = Array.isArray(results) ? results : [];
-    const byId = new Map(list.map((r) => [Number(r.storyId), r]));
-    return plan.map((p) => {
-      const r = byId.get(p.storyId);
-      if (r) return { storyId: p.storyId, ...r };
-      return {
-        storyId: p.storyId,
-        status: 'failed',
-        detail: 'dispatch returned no result for this story',
-      };
-    });
-  }
-}

package/.agents/scripts/lib/orchestration/epic-runner/story-run-progress-writer.js

@@ -1,400 +0,0 @@
-/**
- * story-run-progress-writer — render the per-story progress snapshot.
- *
- * Story #3909 — this module no longer **posts** a `story-run-progress`
- * structured comment. That per-Story comment was the redundant mid-flight
- * progress surface: an Epic run already keeps the operator-facing
- * `epic-run-progress` rollup (one comment on the Epic) plus the
- * `epic-run-state` checkpoint and the lifecycle ledger, and the rollup is
- * rendered from the checkpoint `waves[]` — it never read the per-Story
- * comment. The per-Story comment fired at five phase transitions each and
- * duplicated state already on the labels + ledger, so the comment write was
- * removed.
- *
- * The renderer survives because its `{ body, payload }` output still feeds
- * two non-comment contracts: the `renderedBody` markdown the `/deliver`
- * and `single-story-deliver` CLIs (`story-phase.js`, the inline `story-init.js` prepare step)
- * relay to chat so the operator sees the phase table inline, and the snapshot
- * payload returned in those CLIs' JSON envelopes. `upsertStoryRunProgress`
- * therefore renders-only: it computes the body/payload and (optionally) mirrors
- * a low-severity webhook event, but writes no GitHub comment.
- *
- * Payload shape — per tech spec #902 (kept stable; the CLI envelopes carry it
- * verbatim):
- *
- *   {
- *     "kind": "story-run-progress",
- *     "storyId": <number>,
- *     "branch": "story-<id>",
- *     "phase": "init|implementing|closing|blocked|done",
- *     "tasks": [
- *       { "id": <n>, "title": "...", "state": "done", "commitSha": "abc1234" },
- *       { "id": <n>, "title": "...", "state": "executing" },
- *       { "id": <n>, "title": "...", "state": "pending" }
- *     ],
- *     "updatedAt": "<iso8601>"
- *   }
- */
-
-export const STORY_RUN_PROGRESS_TYPE = 'story-run-progress';
-
-const VALID_TASK_STATES = new Set([
-  'pending',
-  'executing',
-  'done',
-  'blocked',
-  'failed',
-]);
-
-const VALID_PHASES = new Set([
-  'init',
-  'implementing',
-  'closing',
-  'blocked',
-  'done',
-]);
-
-const TASK_STATE_EMOJI = {
-  pending: '⏳',
-  executing: '🔧',
-  done: '✅',
-  blocked: '🚧',
-  failed: '❌',
-};
-
-const PHASE_EMOJI = {
-  init: '🌱',
-  implementing: '🔧',
-  closing: '🔒',
-  blocked: '🚧',
-  done: '✅',
-};
-
-/**
- * Canonical 2-tier Story-phase order. The Story-phase snapshot replaces the
- * 4-tier per-Task list when the Story carries inline acceptance (no child
- * Tasks). Each entry tracks `status` + `startedAt` / `endedAt` so the parent
- * `/deliver` aggregator can render a coarse progress bar without
- * walking Task tickets.
- */
-export const STORY_PHASE_ORDER = ['init', 'implement', 'validate', 'close'];
-
-const VALID_STORY_PHASE_STATUS = new Set(['pending', 'in-progress', 'done']);
-
-const STORY_PHASE_STATUS_EMOJI = {
-  pending: '⏳',
-  'in-progress': '🔧',
-  done: '✅',
-};
-
-/**
- * Build the canonical default `phases[]` array for a freshly-initialized
- * 2-tier Story snapshot. All entries are `pending`; timestamps are null.
- * Exported so call sites (the story-init prepare step, story-phase) and
- * tests can build the same shape without re-implementing it.
- *
- * @returns {Array<{ name: string, status: 'pending', startedAt: null, endedAt: null }>}
- */
-export function defaultStoryPhases() {
-  return STORY_PHASE_ORDER.map((name) => ({
-    name,
-    status: 'pending',
-    startedAt: null,
-    endedAt: null,
-  }));
-}
-
-/**
- * Normalize one Story-phase row into the canonical schema. Timestamps may be
- * `null` (phase not yet started) or ISO-8601 strings; status is one of
- * pending | in-progress | done.
- *
- * @param {object} phase
- * @returns {object}
- */
-function normalizeStoryPhase(phase) {
-  if (!phase || typeof phase !== 'object') {
-    throw new TypeError('story-run-progress phase rows must be objects');
-  }
-  const name = String(phase.name ?? '');
-  if (!STORY_PHASE_ORDER.includes(name)) {
-    throw new RangeError(
-      `story-run-progress invalid phase name "${name}"; ` +
-        `expected one of: ${STORY_PHASE_ORDER.join(', ')}`,
-    );
-  }
-  const status = String(phase.status ?? 'pending');
-  if (!VALID_STORY_PHASE_STATUS.has(status)) {
-    throw new RangeError(
-      `story-run-progress invalid phase status "${status}" for "${name}"; ` +
-        `expected one of: ${[...VALID_STORY_PHASE_STATUS].join(', ')}`,
-    );
-  }
-  return {
-    name,
-    status,
-    startedAt: phase.startedAt == null ? null : String(phase.startedAt),
-    endedAt: phase.endedAt == null ? null : String(phase.endedAt),
-  };
-}
-
-/**
- * Normalize one Task row into the canonical schema. `commitSha` is only
- * carried on `done` rows (it has no meaning before the commit lands and is
- * cleared on rollback).
- *
- * @param {object} task
- * @returns {object}
- */
-function normalizeTask(task) {
-  if (!task || typeof task !== 'object') {
-    throw new TypeError('story-run-progress task rows must be objects');
-  }
-  const id = Number(task.id ?? task.taskId);
-  if (!Number.isInteger(id) || id <= 0) {
-    throw new TypeError(
-      `story-run-progress task row missing valid id: ${JSON.stringify(task)}`,
-    );
-  }
-  const state = String(task.state ?? 'pending');
-  if (!VALID_TASK_STATES.has(state)) {
-    throw new RangeError(
-      `story-run-progress invalid task state "${state}" for task #${id}; ` +
-        `expected one of: ${[...VALID_TASK_STATES].join(', ')}`,
-    );
-  }
-  const row = { id, title: String(task.title ?? ''), state };
-  if (state === 'done' && task.commitSha != null) {
-    row.commitSha = String(task.commitSha);
-  }
-  return row;
-}
-
-/**
- * Build the markdown body the writer upserts. Pure: no IO, no provider call.
- * Exported so tests can pin the rendered shape without going through the
- * upsert path.
- *
- * Two shapes are supported, selected by whether `input.phases` (2-tier
- * Story-phase snapshot) or `input.tasks` (legacy 4-tier per-Task list) is
- * provided. Callers MUST pass exactly one of the two — passing both is
- * rejected as a contract violation so a mistake at the call site fails
- * loudly rather than silently dropping one shape.
- *
- * @param {{
- *   storyId: number,
- *   branch: string,
- *   phase: string,
- *   tasks?: object[],
- *   phases?: object[],
- *   updatedAt?: string,
- * }} input
- * @returns {{ body: string, payload: object }}
- */
-export function renderStoryRunProgressBody(input) {
-  const storyId = Number(input?.storyId);
-  if (!Number.isInteger(storyId) || storyId <= 0) {
-    throw new TypeError(
-      'renderStoryRunProgressBody requires a numeric storyId',
-    );
-  }
-  const branch = String(input?.branch ?? '');
-  if (!branch) {
-    throw new TypeError(
-      'renderStoryRunProgressBody requires a non-empty branch',
-    );
-  }
-  const phase = String(input?.phase ?? '');
-  if (!VALID_PHASES.has(phase)) {
-    throw new RangeError(
-      `renderStoryRunProgressBody invalid phase "${phase}"; ` +
-        `expected one of: ${[...VALID_PHASES].join(', ')}`,
-    );
-  }
-
-  const hasPhases = Array.isArray(input.phases);
-  const hasTasks = Array.isArray(input.tasks);
-  if (hasPhases && hasTasks) {
-    throw new TypeError(
-      'renderStoryRunProgressBody: pass either `phases` (2-tier) or `tasks` ' +
-        '(4-tier), not both — the snapshot shape is mutually exclusive.',
-    );
-  }
-
-  const updatedAt = input.updatedAt ?? new Date().toISOString();
-
-  if (hasPhases) {
-    return renderPhasesBody({
-      storyId,
-      branch,
-      phase,
-      phases: input.phases,
-      updatedAt,
-    });
-  }
-  return renderTasksBody({
-    storyId,
-    branch,
-    phase,
-    tasks: input.tasks ?? [],
-    updatedAt,
-  });
-}
-
-/**
- * Render the 4-tier per-Task body. Pure helper for `renderStoryRunProgressBody`.
- */
-function renderTasksBody({
-  storyId,
-  branch,
-  phase,
-  tasks: rawTasks,
-  updatedAt,
-}) {
-  const tasks = rawTasks.map(normalizeTask);
-  const payload = {
-    kind: STORY_RUN_PROGRESS_TYPE,
-    storyId,
-    branch,
-    phase,
-    tasks,
-    updatedAt,
-  };
-
-  const done = tasks.filter((t) => t.state === 'done').length;
-  const total = tasks.length;
-  const phaseEmoji = PHASE_EMOJI[phase] ?? '';
-  const header = `### 📖 Story #${storyId} — ${phaseEmoji} ${phase} · ${done}/${total} tasks done`;
-  const tableRows = tasks.length
-    ? [
-        '| ID | State | Title | Commit |',
-        '| --- | --- | --- | --- |',
-        ...tasks.map((t) => {
-          const emoji = TASK_STATE_EMOJI[t.state] ?? '';
-          const commit = t.commitSha
-            ? `\`${String(t.commitSha).slice(0, 7)}\``
-            : '—';
-          const title = String(t.title).replace(/\|/g, '\\|');
-          return `| #${t.id} | ${emoji} ${t.state} | ${title} | ${commit} |`;
-        }),
-      ].join('\n')
-    : '_(no tasks recorded for this story)_';
-
-  const body = [
-    header,
-    '',
-    `Branch: \`${branch}\``,
-    '',
-    tableRows,
-    '',
-    '```json',
-    JSON.stringify(payload, null, 2),
-    '```',
-  ].join('\n');
-
-  return { body, payload };
-}
-
-/**
- * Render the 2-tier Story-phase body. Pure helper for
- * `renderStoryRunProgressBody`. Emits a `phases[]` payload whose entries
- * carry `{ name, status, startedAt, endedAt }` for init/implement/validate/close.
- */
-function renderPhasesBody({ storyId, branch, phase, phases: raw, updatedAt }) {
-  const phases = raw.map(normalizeStoryPhase);
-  const payload = {
-    kind: STORY_RUN_PROGRESS_TYPE,
-    storyId,
-    branch,
-    phase,
-    phases,
-    updatedAt,
-  };
-
-  const done = phases.filter((p) => p.status === 'done').length;
-  const total = phases.length;
-  const phaseEmoji = PHASE_EMOJI[phase] ?? '';
-  const header = `### 📖 Story #${storyId} — ${phaseEmoji} ${phase} · ${done}/${total} phases done`;
-  const tableRows = phases.length
-    ? [
-        '| Phase | Status | Started | Ended |',
-        '| --- | --- | --- | --- |',
-        ...phases.map((p) => {
-          const emoji = STORY_PHASE_STATUS_EMOJI[p.status] ?? '';
-          const started = p.startedAt ?? '—';
-          const ended = p.endedAt ?? '—';
-          return `| ${p.name} | ${emoji} ${p.status} | ${started} | ${ended} |`;
-        }),
-      ].join('\n')
-    : '_(no phases recorded for this story)_';
-
-  const body = [
-    header,
-    '',
-    `Branch: \`${branch}\``,
-    '',
-    tableRows,
-    '',
-    '```json',
-    JSON.stringify(payload, null, 2),
-    '```',
-  ].join('\n');
-
-  return { body, payload };
-}
-
-/**
- * Render the story-run-progress snapshot for one phase transition and return
- * `{ body, payload }` so callers can surface the markdown body to chat and
- * carry the payload in their JSON envelope. Story #3909 — this no longer posts
- * a GitHub comment (the redundant mid-flight progress surface was deleted); it
- * renders only and, when `notify` is supplied, mirrors a low-severity webhook
- * event for operators who wire one up.
- *
- * Two shapes are supported, selected by whether `args.phases` (2-tier
- * Story-phase snapshot) or `args.tasks` (legacy 4-tier per-Task list) is
- * provided. The webhook mirror's `done/total` count is computed from whichever
- * shape is active.
- *
- * @param {{
- *   provider?: import('../../ITicketingProvider.js').ITicketingProvider,
- *   storyId: number,
- *   branch: string,
- *   phase: string,
- *   tasks?: object[],
- *   phases?: object[],
- *   epicId?: number,
- *   updatedAt?: string,
- *   notify?: Function,
- * }} args
- * @returns {Promise<{ body: string, payload: object }>}
- */
-export async function upsertStoryRunProgress(args) {
-  const { notify, epicId, provider: _provider, ...rest } = args ?? {};
-  const { body, payload } = renderStoryRunProgressBody(rest);
-  if (typeof notify === 'function') {
-    const isPhases = Array.isArray(payload.phases);
-    const items = isPhases ? payload.phases : payload.tasks;
-    const done = isPhases
-      ? items.filter((p) => p.status === 'done').length
-      : items.filter((t) => t.state === 'done').length;
-    const total = items.length;
-    const unit = isPhases ? 'phases' : 'tasks';
-    const message = `Story #${payload.storyId} · ${payload.phase} · ${done}/${total} ${unit} done`;
-    await Promise.resolve(
-      notify(
-        payload.storyId,
-        {
-          severity: 'low',
-          message,
-          event: STORY_RUN_PROGRESS_TYPE,
-          level: 'story',
-          epicId,
-          phase: payload.phase,
-        },
-        { skipComment: true },
-      ),
-    ).catch(() => {});
-  }
-  return { body, payload };
-}