@skrr-ai/cli 0.1.8

package/dist/commands/tasks/list.js

@@ -0,0 +1,353 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildListParams = buildListParams;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const web_url_1 = require("../../lib/web-url");
+const format_1 = require("../../lib/format");
+/**
+ * The task-list request bag is shared with import/export so every CLI list
+ * surface serializes the same server-side filters. Keep user-id resolution in
+ * the command; this function is deliberately pure for reuse and parity tests.
+ */
+function buildListParams(flags, assigneeUserId) {
+    const flag = (name) => flags[name];
+    return {
+        spaceId: flag('space'),
+        goalId: flag('goal'),
+        projectId: flag('project'),
+        cycleId: flag('cycle'),
+        parentId: flag('parent'),
+        ...(flag('status') ? { status: flag('status') } : {}),
+        ...(flag('status-type') ? { statusType: flag('status-type') } : {}),
+        ...(flag('execution-state')
+            ? { executionState: flag('execution-state') }
+            : {}),
+        ...(flag('actionable-by')
+            ? { actionableBy: flag('actionable-by') }
+            : {}),
+        ...(flag('actionable-for-agent')
+            ? { actionableForAgentId: flag('actionable-for-agent') }
+            : {}),
+        ...(flag('needs-me') ? { actionableForMe: true, actionableBy: 'human' } : {}),
+        ...(flag('actionability-state')
+            ? { actionabilityState: flag('actionability-state') }
+            : {}),
+        ...(flag('actionability-reason')
+            ? { actionabilityReason: flag('actionability-reason') }
+            : {}),
+        ...(flag('actionable-by') ||
+            flag('actionable-for-agent') ||
+            flag('needs-me') ||
+            flag('actionability-state') ||
+            flag('actionability-reason')
+            ? { includeActionability: true }
+            : {}),
+        ...(flag('priority') ? { priority: flag('priority') } : {}),
+        ...(flag('estimate') !== undefined ? { estimate: flag('estimate') } : {}),
+        ...(flag('min-estimate') !== undefined
+            ? { minEstimate: flag('min-estimate') }
+            : {}),
+        ...(flag('assignee-agent') ? { assigneeAgentId: flag('assignee-agent') } : {}),
+        ...(assigneeUserId ? { assigneeUserId } : {}),
+        ...(flag('dri') ? { driId: flag('dri') } : {}),
+        ...(flag('dri-kind') ? { driKind: flag('dri-kind') } : {}),
+        ...(flag('explicit-only') ? { explicitOnly: true } : {}),
+        ...(flag('subscribed') ? { subscribed: true } : {}),
+        ...(flag('include-snoozed') ? { includeSnoozed: true } : {}),
+        ...(flag('external-key')
+            ? { externalKey: flag('external-key') }
+            : {}),
+        ...(flag('blocked-by') ? { blockedBy: flag('blocked-by') } : {}),
+        ...(flag('blocks') ? { blocks: flag('blocks') } : {}),
+        ...(flag('due-before') ? { dueBefore: flag('due-before') } : {}),
+        ...(flag('due-after') ? { dueAfter: flag('due-after') } : {}),
+        ...(flag('overdue') ? { overdue: true } : {}),
+        ...(flag('sort') ? { sort: flag('sort') } : {}),
+        ...(flag('order') ? { order: flag('order') } : {}),
+        ...(Array.isArray(flag('tag')) && flag('tag').length > 0
+            ? { tags: flag('tag') }
+            : {}),
+        ...(Array.isArray(flag('label-id')) && flag('label-id').length > 0
+            ? { labelIds: flag('label-id') }
+            : {}),
+        q: flag('q'),
+        limit: flag('limit'),
+        cursor: flag('cursor'),
+    };
+}
+class TasksList extends base_command_1.BaseCommand {
+    static description = 'List tasks';
+    static examples = [
+        '<%= config.bin %> tasks list',
+        '<%= config.bin %> tasks list --space <space-id>',
+        '<%= config.bin %> tasks list --goal <goal-id> --status in_progress',
+        '<%= config.bin %> tasks list --space <space-id> --cycle current',
+        '<%= config.bin %> tasks list --space <space-id> --external-key ws0/root --json',
+        '<%= config.bin %> tasks list --q "login bug" --json',
+        '<%= config.bin %> tasks list --tag urgent --tag follow-up',
+        '<%= config.bin %> tasks list --label-id <label-id> --status in_progress',
+        '<%= config.bin %> tasks list --assignee-agent <agent-id> --json',
+        '<%= config.bin %> tasks list --assignee-user <user-id>',
+        '<%= config.bin %> tasks list --mine',
+        '<%= config.bin %> tasks list --subscribed',
+        '<%= config.bin %> tasks list --include-snoozed',
+        '<%= config.bin %> tasks list --actionable-by agent --actionable-for-agent <agent-id>',
+        '<%= config.bin %> tasks list --needs-me',
+        '<%= config.bin %> tasks list --dri me',
+        '<%= config.bin %> tasks list --calendar 2026-08-01..2026-08-31 --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        space: core_1.Flags.string({ description: 'Filter by space ID' }),
+        goal: core_1.Flags.string({ description: 'Filter by goal ID' }),
+        project: core_1.Flags.string({ description: 'Filter by project ID' }),
+        cycle: core_1.Flags.string({
+            description: 'Filter by planning cycle ID, or "current" / "next" (requires --space)',
+        }),
+        parent: core_1.Flags.string({ description: 'Filter by parent task ID' }),
+        status: core_1.Flags.string({ description: 'Filter by task status' }),
+        'status-type': core_1.Flags.string({
+            description: 'Filter by fixed workflow TYPE (independent of Space state names)',
+            options: [
+                'backlog',
+                'unstarted',
+                'started',
+                'review',
+                'completed',
+                'cancelled',
+                'triage',
+                'failed',
+                'blocked',
+                'hidden',
+            ],
+        }),
+        'execution-state': core_1.Flags.string({
+            description: 'Filter by execution state, not board status: "active" (running now — in_progress OR checked out OR live session) or "recovered" (startable again after a reaped/failed run). Surfaces reaped runs that --status in_progress hides.',
+            options: ['active', 'recovered'],
+        }),
+        'actionable-by': core_1.Flags.string({
+            description: 'Filter by the server-computed next actor',
+            options: ['agent', 'human'],
+        }),
+        'actionable-for-agent': core_1.Flags.string({
+            description: 'Filter to ready work this Agent is eligible to execute',
+        }),
+        'needs-me': core_1.Flags.boolean({
+            description: 'Filter to Human-actionable work addressed to you',
+        }),
+        sort: core_1.Flags.string({
+            description: 'Order by a shared saved-view field',
+            options: [...data_provider_1.VIEW_SORT_KEYS],
+        }),
+        order: core_1.Flags.string({ description: 'Sort direction', options: [...data_provider_1.VIEW_SORT_DIRECTIONS] }),
+        'due-before': core_1.Flags.string({ description: 'Only tasks due before an ISO timestamp or "now"' }),
+        'due-after': core_1.Flags.string({ description: 'Only tasks due after an ISO timestamp or "now"' }),
+        overdue: core_1.Flags.boolean({
+            description: 'Alias for --due-before now --status-type open; uses the shared legacy open-status band until configurable workflow states land',
+        }),
+        'blocked-by': core_1.Flags.string({ description: 'Only tasks blocked by this task ID' }),
+        blocks: core_1.Flags.string({ description: 'Only tasks that block this task ID' }),
+        'actionability-state': core_1.Flags.string({
+            description: 'Filter by readiness state',
+            options: ['ready', 'running', 'waiting', 'terminal'],
+        }),
+        'actionability-reason': core_1.Flags.string({
+            description: 'Filter by machine-readable readiness reason code',
+        }),
+        priority: core_1.Flags.string({ description: 'Filter by task priority' }),
+        estimate: core_1.Flags.integer({ description: 'Filter by an exact estimate value' }),
+        'min-estimate': core_1.Flags.integer({
+            description: 'Filter to tasks estimated at or above this value',
+        }),
+        // Both filters are applied server-side (GET /api/tasks reads assigneeAgentId /
+        // assigneeUserId) but had no CLI flag, so "what is this agent working on?"
+        // meant listing everything and filtering assigneeAgentIds in jq.
+        'assignee-agent': core_1.Flags.string({ description: 'Filter to tasks assigned to this agent ID' }),
+        'assignee-user': core_1.Flags.string({
+            description: 'Filter to tasks assigned to this user ID (or "me" for yourself)',
+        }),
+        // `GET /api/tasks` special-cases `assigneeUserId === req.user.id` so it can
+        // return work assigned to you from spaces you don't otherwise own. That
+        // cross-space "what's on my plate" view existed server-side but was
+        // unreachable without pasting your own ObjectId.
+        mine: core_1.Flags.boolean({
+            description: 'Filter to tasks assigned to you (alias for --assignee-user me)',
+        }),
+        dri: core_1.Flags.string({
+            description: 'Filter by accountable DRI: "me", user ID, or agent ID (use --dri-kind)',
+        }),
+        'dri-kind': core_1.Flags.string({
+            description: 'Kind of --dri (required for non-me values)',
+            options: ['user', 'agent'],
+        }),
+        'explicit-only': core_1.Flags.boolean({
+            description: 'With --dri, ignore inherited Goal/Space/author responsibility',
+        }),
+        subscribed: core_1.Flags.boolean({
+            description: 'Filter to your active direct task subscriptions (your task watch list)',
+        }),
+        'include-snoozed': core_1.Flags.boolean({
+            description: 'Include tasks you have personally snoozed (hidden by default)',
+        }),
+        'external-key': core_1.Flags.string({ description: 'Filter by external key' }),
+        tag: core_1.Flags.string({
+            description: 'Filter to tasks carrying EVERY listed tag (repeatable, AND-intersection, ' +
+                'case-insensitive)',
+            multiple: true,
+        }),
+        'label-id': core_1.Flags.string({
+            description: 'Filter to tasks carrying EVERY listed label id (repeatable, AND-intersection)',
+            multiple: true,
+        }),
+        q: core_1.Flags.string({ description: 'Free-text search query' }),
+        limit: core_1.Flags.integer({ description: 'Max results', default: 50 }),
+        cursor: core_1.Flags.string({ description: 'Pagination cursor from a previous page' }),
+        calendar: core_1.Flags.string({
+            description: 'Expand the human task calendar for an inclusive range (YYYY-MM-DD..YYYY-MM-DD or ISO instants). Includes due dates and agent schedule occurrences.',
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(TasksList);
+        let calendarRange;
+        if (flags.calendar) {
+            const [from, to, extra] = flags.calendar.split('..');
+            if (!from?.trim() || !to?.trim() || extra !== undefined) {
+                this.failWithCliError({
+                    message: '--calendar must be <from>..<to>, for example 2026-08-01..2026-08-31.',
+                    code: 'TASK_CALENDAR_RANGE_INVALID',
+                    exit: 2,
+                    retryable: false,
+                });
+                return;
+            }
+            calendarRange = { from: from.trim(), to: to.trim() };
+        }
+        if (flags.mine && flags['assignee-user']) {
+            this.failWithCliError({
+                message: '--mine and --assignee-user are mutually exclusive.',
+                code: 'TASK_LIST_FLAG_CONFLICT',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        // One round-trip to `GET /api/user`, and only when the caller actually
+        // asked for a self-scoped view.
+        const assigneeUserId = flags.mine || flags['assignee-user']?.trim().toLowerCase() === 'me'
+            ? await this.resolveCurrentUserId()
+            : flags['assignee-user'];
+        let driId = flags.dri;
+        let driKind = flags['dri-kind'];
+        if (driId?.trim().toLowerCase() === 'me') {
+            driId = await this.resolveCurrentUserId();
+            driKind = 'user';
+        }
+        if (driId && !driKind) {
+            this.failWithCliError({
+                message: '--dri requires --dri-kind user or agent (except --dri me).',
+                code: 'TASK_DRI_KIND_REQUIRED',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        flags.dri = driId;
+        flags['dri-kind'] = driKind;
+        let response;
+        try {
+            response = calendarRange
+                ? await data_provider_1.dataService.getTaskCalendar({
+                    ...calendarRange,
+                    ...(flags.space ? { spaceId: flags.space } : {}),
+                    ...(flags.project ? { projectId: flags.project } : {}),
+                    ...(flags.status ? { status: flags.status } : {}),
+                })
+                : await data_provider_1.dataService.listTasks(buildListParams(flags, assigneeUserId));
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify((0, web_url_1.withDataUrls)(this.cliConfig.baseURL, response, web_url_1.taskUrlFrom), null, 2));
+            return;
+        }
+        if (calendarRange) {
+            const calendar = response;
+            const occurrences = calendar.data ?? [];
+            if (occurrences.length === 0) {
+                this.log('No calendar occurrences.');
+                return;
+            }
+            (0, format_1.renderTable)(occurrences.map((item) => ({
+                when: String(item.occursAt ?? '-'),
+                kind: String(item.kind ?? '-'),
+                ident: String(item.task?.identifier ?? '-'),
+                title: String(item.task?.title ?? '-'),
+                status: String(item.task?.status ?? '-'),
+            })), [
+                { key: 'when', header: 'WHEN' },
+                { key: 'kind', header: 'KIND' },
+                { key: 'ident', header: 'REF' },
+                { key: 'title', header: 'TITLE', maxWidth: 50 },
+                { key: 'status', header: 'STATUS' },
+            ], (line) => this.log(line));
+            if (calendar.truncated)
+                this.log('\nNote: calendar occurrence expansion reached its safety cap.');
+            return;
+        }
+        const r = response;
+        const items = r?.data ?? [];
+        if (items.length === 0) {
+            this.log('No tasks.');
+            // `--status in_progress` filters the board column only. A run that was
+            // reaped/reset (e.g. a stuck-task timeout) is moved OFF `in_progress` but
+            // keeps its execution markers, so it hides here. Point the operator at the
+            // execution-state views that still surface it.
+            if (flags.status === 'in_progress' && !flags['execution-state']) {
+                this.log('');
+                this.log('Note: `--status in_progress` shows only the board column. A reaped or reset run');
+                this.log('      no longer has that status. Try `--execution-state active` (running now) or');
+                this.log('      `--execution-state recovered` (reaped, startable), or `skrr tasks active`.');
+            }
+            return;
+        }
+        const rows = items.map((t) => {
+            const agents = Array.isArray(t.assigneeAgentIds) ? t.assigneeAgentIds.length : 0;
+            const users = Array.isArray(t.assigneeUserIds) ? t.assigneeUserIds.length : 0;
+            const assignees = agents + users > 0 ? `${agents}a/${users}u` : '-';
+            const actionability = t.actionability;
+            return {
+                id: String(t.id ?? t._id ?? '-'),
+                ident: String(t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '-')),
+                title: String(t.title ?? '-'),
+                status: String(t.status ?? '-'),
+                priority: String(t.priority ?? '-'),
+                estimate: t.estimate === null || t.estimate === undefined ? '-' : String(t.estimate),
+                assignees,
+                next: actionability
+                    ? `${String(actionability.nextActor ?? '-')}:${String(actionability.reasonCode ?? actionability.state ?? '-')}`
+                    : String(t.executionMode ?? '-'),
+                match: String(t._matchField ?? '-'),
+            };
+        });
+        (0, format_1.renderTable)(rows, [
+            { key: 'ident', header: 'REF' },
+            { key: 'title', header: 'TITLE', maxWidth: 50 },
+            { key: 'status', header: 'STATUS' },
+            { key: 'priority', header: 'PRIORITY' },
+            { key: 'estimate', header: 'ESTIMATE' },
+            { key: 'assignees', header: 'ASSIGNEES' },
+            { key: 'next', header: 'NEXT' },
+            // Only meaningful on a search — the server computes it from the same
+            // relevance rank that orders the rows, and a plain listing has none.
+            ...(flags.q ? [{ key: 'match', header: 'MATCH' }] : []),
+            { key: 'id', header: 'ID' },
+        ], (line) => this.log(line));
+        if (r?.next_cursor) {
+            this.log('');
+            this.log(`Next page: --cursor ${r.next_cursor}`);
+        }
+    }
+}
+exports.default = TasksList;

package/dist/commands/tasks/mark-duplicate.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command';
+export default class TasksMarkDuplicate extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        of: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/mark-duplicate.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+class TasksMarkDuplicate extends base_command_1.BaseCommand {
+    static description = 'Mark a task as a duplicate and merge collaboration into the canonical task';
+    static args = {
+        id: core_1.Args.string({ description: 'Duplicate task ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        of: core_1.Flags.string({ description: 'Canonical task ID', required: true }),
+        json: core_1.Flags.boolean({ description: 'Output the merge result as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksMarkDuplicate);
+        let result;
+        try {
+            result = (await data_provider_1.dataService.markTaskDuplicate({
+                taskId: args.id,
+                canonicalTaskId: flags.of,
+            }));
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(result, null, 2));
+        const duplicate = (result?.duplicate || {});
+        const canonical = (result?.canonical || {});
+        this.log(`Marked ${duplicate.identifier ?? args.id} as duplicate of ${canonical.identifier ?? flags.of}`);
+    }
+}
+exports.default = TasksMarkDuplicate;

package/dist/commands/tasks/monitor.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command';
+export default class TasksMonitor extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        limit: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'fail-on': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'timeline-limit': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'health-limit': import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/monitor.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+const tasks_1 = require("../../lib/tasks");
+const task_execution_1 = require("../../lib/task-execution");
+class TasksMonitor extends base_command_1.BaseCommand {
+    static description = 'Show an execution control-plane snapshot for a task tree';
+    static examples = [
+        '<%= config.bin %> tasks monitor <root-task-id>',
+        '<%= config.bin %> tasks monitor <root-task-id> --limit 1000 --json',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Root task ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        limit: core_1.Flags.integer({ description: 'Max descendants to inspect', default: 500 }),
+        'fail-on': core_1.Flags.string({
+            description: 'Comma-separated statuses treated as failures',
+            default: task_execution_1.DEFAULT_FAIL_STATUSES_FLAG,
+        }),
+        'timeline-limit': core_1.Flags.integer({
+            description: 'Timeline entries to fetch per active task',
+            default: 5,
+        }),
+        'health-limit': core_1.Flags.integer({
+            description: 'Max tasks to inspect for execution health',
+            default: 50,
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksMonitor);
+        const failOn = (0, task_execution_1.parseStatusSet)(flags['fail-on'], task_execution_1.DEFAULT_FAIL_STATUSES);
+        let tasks;
+        try {
+            tasks = await (0, task_execution_1.fetchTaskSet)({
+                rootId: args.id,
+                descendants: true,
+                limit: flags.limit,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const snapshot = (0, task_execution_1.buildSnapshot)(tasks, failOn, args.id);
+        const timelineLimit = Math.max(1, Math.min(flags['timeline-limit'], 20));
+        const healthLimit = Math.max(1, Math.min(flags['health-limit'], 200));
+        const healthTasks = executionHealthCandidates(snapshot.tasks, healthLimit);
+        const [recentEvents, executionHealth] = await Promise.all([
+            fetchRecentEvents(snapshot.activeTasks, timelineLimit),
+            fetchExecutionHealth(healthTasks),
+        ]);
+        const result = {
+            ...snapshot,
+            executionHealth,
+            recentEvents,
+        };
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Task tree: ${args.id}`);
+        this.log(`Tasks: ${snapshot.taskCount} | active: ${snapshot.activeCount} | recovered: ${snapshot.recoveredCount} | terminal: ${snapshot.terminalCount} | pending: ${snapshot.pendingCount}`);
+        this.log(`Statuses: ${Object.entries(snapshot.counts)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([status, count]) => `${status}=${count}`)
+            .join(', ')}`);
+        if (snapshot.activeTasks.length > 0) {
+            this.log('');
+            this.log('Active executions:');
+            (0, format_1.renderTable)(snapshot.activeTasks.map(task_execution_1.summarizeTask), [
+                { key: 'ref', header: 'REF' },
+                { key: 'age', header: 'AGE' },
+                { key: 'title', header: 'TITLE', maxWidth: 48 },
+                { key: 'session', header: 'SESSION', maxWidth: 14 },
+                { key: 'conversation', header: 'CONVERSATION', maxWidth: 14 },
+            ], (line) => this.log(line));
+        }
+        if (recentEvents.length > 0) {
+            this.log('');
+            this.log('Recent execution events:');
+            (0, format_1.renderTable)(recentEvents.map((event) => ({
+                ref: event.ref,
+                event: event.event,
+                time: event.time,
+                run: event.run,
+            })), [
+                { key: 'ref', header: 'REF' },
+                { key: 'event', header: 'EVENT', maxWidth: 28 },
+                { key: 'time', header: 'TIME' },
+                { key: 'run', header: 'RUN', maxWidth: 14 },
+            ], (line) => this.log(line));
+        }
+        if (executionHealth.length > 0) {
+            this.log('');
+            this.log('Execution health:');
+            (0, format_1.renderTable)(executionHealth.map((entry) => ({
+                ref: entry.ref,
+                status: entry.status,
+                health: entry.health,
+                age: entry.latestEventAge,
+                event: entry.latestEvent,
+                run: entry.run,
+                reason: entry.reason,
+                warnings: entry.warnings,
+            })), [
+                { key: 'ref', header: 'REF' },
+                { key: 'status', header: 'STATUS' },
+                { key: 'health', header: 'HEALTH', maxWidth: 24 },
+                { key: 'age', header: 'AGE' },
+                { key: 'event', header: 'EVENT', maxWidth: 22 },
+                { key: 'run', header: 'RUN', maxWidth: 14 },
+                { key: 'reason', header: 'REASON', maxWidth: 36 },
+                { key: 'warnings', header: 'WARN', maxWidth: 40 },
+            ], (line) => this.log(line));
+        }
+        if (snapshot.recoveredTasks.length > 0) {
+            this.log('');
+            this.log('Recovered stale executions:');
+            (0, format_1.renderTable)(snapshot.recoveredTasks.map(task_execution_1.summarizeTask), [
+                { key: 'ref', header: 'REF' },
+                { key: 'status', header: 'STATUS' },
+                { key: 'age', header: 'LAST AGE' },
+                { key: 'attempts', header: 'TRY' },
+                { key: 'note', header: 'NOTE', maxWidth: 32 },
+                { key: 'title', header: 'TITLE', maxWidth: 46 },
+                { key: 'error', header: 'ERROR', maxWidth: 44 },
+            ], (line) => this.log(line));
+            this.log('Use `skrr tasks continue-ready --retry-recovered <root-id>` to retry explicitly.');
+        }
+        if (snapshot.failureTasks.length > 0) {
+            this.log('');
+            this.log('Failures:');
+            (0, format_1.renderTable)(snapshot.failureTasks.map(task_execution_1.summarizeTask), [
+                { key: 'ref', header: 'REF' },
+                { key: 'status', header: 'STATUS' },
+                { key: 'title', header: 'TITLE', maxWidth: 56 },
+                { key: 'error', header: 'ERROR', maxWidth: 40 },
+            ], (line) => this.log(line));
+        }
+    }
+}
+exports.default = TasksMonitor;
+function executionHealthCandidates(tasks, limit) {
+    const seen = new Set();
+    const candidates = [];
+    for (const task of tasks) {
+        const id = (0, tasks_1.taskId)(task);
+        if (!id || seen.has(id))
+            continue;
+        if ((0, task_execution_1.statusOf)(task) === 'in_progress' ||
+            Boolean(task.checkoutRunId) ||
+            Boolean(task.sessionId) ||
+            Number(task.executionAttempts) > 0 ||
+            Boolean(task.executionError)) {
+            seen.add(id);
+            candidates.push(task);
+        }
+        if (candidates.length >= limit)
+            break;
+    }
+    return candidates;
+}
+async function fetchExecutionHealth(tasks) {
+    const responses = await Promise.all(tasks.map(async (task) => {
+        try {
+            const summary = (await data_provider_1.dataService.getTaskExecutionSummary((0, tasks_1.taskId)(task)));
+            const health = summary.executionHealth;
+            if (!health)
+                return null;
+            const warnings = Array.isArray(health.warnings)
+                ? health.warnings.map((warning) => String(warning)).join(', ')
+                : '';
+            return {
+                ref: (0, tasks_1.taskRef)(task) || '-',
+                taskId: (0, tasks_1.taskId)(task),
+                status: (0, task_execution_1.statusOf)(task) || '-',
+                health: String(health.state ?? '-'),
+                reason: String(health.reason ?? '-'),
+                latestEvent: String(health.latestEvent ?? '-'),
+                latestEventAge: (0, task_execution_1.formatDurationMs)(health.latestEventAgeMs),
+                run: String(health.runId ?? '-'),
+                warnings: warnings || '-',
+                raw: health,
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return responses.filter((row) => row !== null);
+}
+async function fetchRecentEvents(tasks, limit) {
+    const responses = await Promise.all(tasks.slice(0, 20).map(async (task) => {
+        try {
+            const response = await data_provider_1.dataService.getTaskExecutionTimeline((0, tasks_1.taskId)(task), undefined, limit);
+            const entries = Array.isArray(response?.data) ? response.data : [];
+            return entries.slice(-limit).map((entry) => {
+                const record = entry;
+                return {
+                    ref: String(task.identifier ?? task.taskNumber ?? '-'),
+                    taskId: (0, tasks_1.taskId)(task),
+                    event: String(record.event ?? record.type ?? '-'),
+                    time: formatTime(record.timestamp ?? record.createdAt),
+                    run: String(record.runId ?? '-'),
+                };
+            });
+        }
+        catch {
+            return [];
+        }
+    }));
+    return responses.flat();
+}
+function formatTime(value) {
+    if (!value)
+        return '-';
+    const date = new Date(String(value));
+    if (Number.isNaN(date.getTime()))
+        return String(value);
+    return date.toISOString().slice(0, 19).replace('T', ' ');
+}