@skrr-ai/cli 0.1.91 → 0.1.93

package/dist/commands/tasks/bulk-update.js

@@ -5,12 +5,15 @@ 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 prompt_1 = require("../../lib/prompt");
+const dry_run_plans_1 = require("../../lib/dry-run-plans");
+const task_batch_1 = require("../../lib/task-batch");
 const tasks_1 = require("../../lib/tasks");
 class TasksBulkUpdate extends base_command_1.BaseCommand {
     static description = 'Apply partial updates to many tasks from JSON';
     static examples = [
         '<%= config.bin %> tasks bulk-update --from-json updates.json --json',
         '<%= config.bin %> tasks bulk-update --from-json updates.json --continue-on-error',
+        '<%= config.bin %> tasks bulk-update --from-json updates.json --dry-run --json',
     ];
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output bulk result as JSON' }),
@@ -18,6 +21,9 @@ class TasksBulkUpdate extends base_command_1.BaseCommand {
             description: 'Path to a JSON file (or "-" for stdin) containing updates',
             required: true,
         }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Read each task, validate every patch client-side and print the field-by-field diff without writing anything',
+        }),
         'continue-on-error': core_1.Flags.boolean({
             description: 'Continue applying later updates after one task fails',
         }),
@@ -39,42 +45,127 @@ class TasksBulkUpdate extends base_command_1.BaseCommand {
         catch (err) {
             this.error(err.message, { exit: 1 });
         }
+        if (flags['dry-run']) {
+            const currentById = {};
+            const failedReads = {};
+            for (const update of updates) {
+                try {
+                    currentById[update.id] = (await data_provider_1.dataService.getTask(update.id, {
+                        enrich: false,
+                    }));
+                }
+                catch (err) {
+                    const status = err.status;
+                    if (status === 404)
+                        currentById[update.id] = null;
+                    else
+                        failedReads[update.id] = err instanceof Error ? err.message : String(err);
+                }
+            }
+            const preview = (0, dry_run_plans_1.planBulkUpdate)(updates, currentById, failedReads);
+            if (flags.json)
+                this.log(JSON.stringify(preview, null, 2));
+            else {
+                this.log(`Dry run: ${preview.wouldChange} of ${preview.requested} task(s) would change, ${preview.invalid} invalid. Nothing was written.`);
+                for (const row of preview.results) {
+                    if (!row.ok)
+                        this.log(`- ${row.id}: ${row.errors.join('; ')}`);
+                    else if (row.noop)
+                        this.log(`- ${row.id}: no change`);
+                    else
+                        this.log(`- ${row.id}: ${Object.keys(row.changes).join(', ')}`);
+                }
+            }
+            if (!preview.ok)
+                this.exit(1);
+            return;
+        }
         const results = [];
         const errors = [];
-        for (const update of updates) {
+        const rows = updates.map((update) => {
+            const { status, ...restPatch } = update.patch;
+            return { id: update.id, status, patch: (0, tasks_1.removeUndefinedFields)(restPatch) };
+        });
+        // The field patches go to PATCH /api/tasks/batch in chunks; `status` is a
+        // workflow move with its own route and stays one call per row. A server
+        // without the batch route (404/405) gets the serial path below.
+        const patchable = rows
+            .map((row, index) => ({ row, index }))
+            .filter(({ row }) => Object.keys(row.patch).length > 0);
+        const batchByRow = new Map();
+        if (patchable.length > 0) {
+            const outcome = await (0, task_batch_1.patchTasksViaBatch)(patchable.map(({ row }) => ({
+                id: row.id,
+                patch: row.patch,
+            })));
+            if (outcome.supported) {
+                for (const [i, result] of outcome.results.entries()) {
+                    batchByRow.set(patchable[i].index, result);
+                }
+            }
+        }
+        const usedBatch = batchByRow.size > 0;
+        let stopped = false;
+        for (const [index, row] of rows.entries()) {
             try {
-                const { status, ...restPatch } = update.patch;
-                const patch = (0, tasks_1.removeUndefinedFields)(restPatch);
                 let task = null;
-                if (Object.keys(patch).length > 0) {
-                    task = await data_provider_1.dataService.updateTask({
-                        taskId: update.id,
-                        data: patch,
-                    });
+                if (Object.keys(row.patch).length > 0) {
+                    const batched = batchByRow.get(index);
+                    if (usedBatch && batched) {
+                        if (!batched.ok) {
+                            throw Object.assign(new Error(batched.error?.message ?? 'Update failed'), {
+                                code: batched.error?.code,
+                                status: batched.error?.status,
+                            });
+                        }
+                        // The batch route reports id/identifier/version, not the document:
+                        // the fields this row set are echoed so the row is self-describing.
+                        task = {
+                            ...row.patch,
+                            id: batched.id ?? row.id,
+                            ...(batched.identifier ? { identifier: batched.identifier } : {}),
+                            ...(batched.version !== undefined ? { version: batched.version } : {}),
+                        };
+                    }
+                    else {
+                        task = await data_provider_1.dataService.updateTask({
+                            taskId: row.id,
+                            data: row.patch,
+                        });
+                    }
                 }
-                if (status !== undefined) {
-                    if (!data_provider_1.TASK_STATUSES.includes(status)) {
+                if (row.status !== undefined) {
+                    if (stopped) {
+                        throw new Error('status move not applied: stopped after an earlier failure');
+                    }
+                    if (!data_provider_1.TASK_STATUSES.includes(row.status)) {
                         throw new Error(`status must be one of: ${data_provider_1.TASK_STATUSES.join(', ')}`);
                     }
                     task = await data_provider_1.dataService.moveTask({
-                        taskId: update.id,
-                        status: status,
+                        taskId: row.id,
+                        status: row.status,
                     });
                 }
                 if (!task) {
-                    task = await data_provider_1.dataService.getTask(update.id, { enrich: false });
+                    task = await data_provider_1.dataService.getTask(row.id, { enrich: false });
                 }
-                results.push({ id: update.id, ok: true, task });
+                results.push({ id: row.id, ok: true, task });
             }
             catch (err) {
+                const code = err.code;
                 const error = {
-                    id: update.id,
+                    id: row.id,
                     ok: false,
                     error: err instanceof Error ? err.message : String(err),
+                    ...(code ? { code } : {}),
                 };
                 errors.push(error);
                 results.push(error);
                 if (!flags['continue-on-error'])
+                    stopped = true;
+                // Serial path: later rows are never touched. Batch path: they were
+                // already applied by the chunk, so they are reported rather than dropped.
+                if (!flags['continue-on-error'] && !usedBatch)
                     break;
             }
         }

package/dist/commands/tasks/cancel-cascade.d.ts

@@ -7,6 +7,7 @@ export default class TasksCancelCascade extends BaseCommand {
     };
     static flags: {
         yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/tasks/cancel-cascade.js

@@ -15,29 +15,39 @@ class TasksCancelCascade extends base_command_1.BaseCommand {
     };
     static flags = {
         yes: core_1.Flags.boolean({ char: 'y', description: 'Skip confirmation prompt' }),
+        json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCancelCascade);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let confirmed;
         try {
-            confirmed = await (0, prompt_1.confirmDestructive)(`Cancel cascade for task ${args.id}? This cannot be undone.`, flags.yes);
+            confirmed = await (0, prompt_1.confirmDestructive)(`Cancel cascade for task ${taskRef}? This cannot be undone.`, flags.yes);
         }
         catch (err) {
             const e = err;
             this.error(e.message, { exit: e.exit ?? 1 });
         }
         if (!confirmed) {
+            if (flags.json) {
+                this.log(JSON.stringify({ object: 'task_cascade_cancel', cancelled: false, id: taskRef }));
+                return;
+            }
             this.log('Cancelled.');
             return;
         }
         try {
-            await data_provider_1.dataService.cancelCascade(args.id);
+            await data_provider_1.dataService.cancelCascade(taskRef);
         }
         catch (err) {
             this.handleApiError(err);
         }
-        this.log(`Cancelled cascade for task ${args.id}`);
+        if (flags.json) {
+            this.log(JSON.stringify({ object: 'task_cascade_cancel', cancelled: true, id: taskRef }));
+            return;
+        }
+        this.log(`Cancelled cascade for task ${taskRef}`);
     }
 }
 exports.default = TasksCancelCascade;

package/dist/commands/tasks/cascade-status.js

@@ -18,9 +18,10 @@ class TasksCascadeStatus extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCascadeStatus);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let result;
         try {
-            result = await data_provider_1.dataService.getCascadeStatus(args.id);
+            result = await data_provider_1.dataService.getCascadeStatus(taskRef);
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/tasks/chat/send.d.ts

@@ -0,0 +1,44 @@
+import { BaseCommand } from '../../../base-command';
+export interface TaskChatSendInput {
+    text: string;
+    commandId?: string;
+    now?: boolean;
+}
+/**
+ * Build the `POST /api/tasks/:id/exchanges/messages` body.
+ *
+ * Every mutation on the task-chat surface requires an actor-scoped `commandId`;
+ * the server refuses to mint one (a server-minted id cannot make the caller's
+ * own retry idempotent). Without `--command-id` each invocation gets a FRESH id,
+ * because two sends of identical text are two intents (the unfenced-write rule
+ * in `idempotency.ts`). Pass the same `--command-id` to retry safely.
+ */
+export declare function buildTaskChatSendBody(input: TaskChatSendInput): {
+    immediate?: boolean | undefined;
+    commandId: string;
+    text: string;
+};
+/** One human line for a send result; never claims dispatch the server did not report. */
+export declare function describeSendResult(result: Record<string, unknown>): string;
+/**
+ * `skrr tasks chat send <task-id> --text "..."` — post a message into a Task's
+ * chat (the Task Multi-Turn Conversation surface).
+ *
+ * By default the message joins the current batch and the agent answers when the
+ * batch closes (several messages, one response). `--now` closes the batch and
+ * dispatches in the same request.
+ */
+export default class TasksChatSend 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>;
+        text: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        now: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'command-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/chat/send.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTaskChatSendBody = buildTaskChatSendBody;
+exports.describeSendResult = describeSendResult;
+const node_crypto_1 = require("node:crypto");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../../base-command");
+const task_extras_1 = require("../../../lib/task-extras");
+/** The server's `appendSchema` bounds on `commandId`. */
+const COMMAND_ID_MIN = 8;
+const COMMAND_ID_MAX = 128;
+/**
+ * Build the `POST /api/tasks/:id/exchanges/messages` body.
+ *
+ * Every mutation on the task-chat surface requires an actor-scoped `commandId`;
+ * the server refuses to mint one (a server-minted id cannot make the caller's
+ * own retry idempotent). Without `--command-id` each invocation gets a FRESH id,
+ * because two sends of identical text are two intents (the unfenced-write rule
+ * in `idempotency.ts`). Pass the same `--command-id` to retry safely.
+ */
+function buildTaskChatSendBody(input) {
+    const text = input.text?.trim() ? input.text : '';
+    if (!text)
+        throw new Error('A message needs non-empty text (--text).');
+    const commandId = input.commandId ?? `cli-${(0, node_crypto_1.randomUUID)()}`;
+    if (commandId.length < COMMAND_ID_MIN) {
+        throw new Error(`--command-id must be at least ${COMMAND_ID_MIN} characters.`);
+    }
+    if (commandId.length > COMMAND_ID_MAX) {
+        throw new Error(`--command-id must be at most ${COMMAND_ID_MAX} characters.`);
+    }
+    return {
+        commandId,
+        text,
+        ...(input.now ? { immediate: true } : {}),
+    };
+}
+/** One human line for a send result; never claims dispatch the server did not report. */
+function describeSendResult(result) {
+    const exchangeId = String(result.exchangeId ?? '?');
+    const replay = result.replay === true ? ' (replay of an earlier send)' : '';
+    if (result.alreadyClosed === true) {
+        return `Exchange ${exchangeId} was already closed${replay}.`;
+    }
+    if (result.materialized === false) {
+        return `Message recorded in exchange ${exchangeId}${replay}, but no run was started: ${String(result.reason ?? 'unknown reason')}.`;
+    }
+    if (result.materialized === true) {
+        const run = result.taskExecutionRunId ? ` as run ${String(result.taskExecutionRunId)}` : '';
+        return `Message sent in exchange ${exchangeId}${replay}; dispatched${run}.`;
+    }
+    const close = result.softCloseAt ? ` Batch closes at ${String(result.softCloseAt)}.` : '';
+    return `Message recorded in exchange ${exchangeId}${replay}; the batch is still collecting, not yet dispatched.${close} Use --now to dispatch immediately.`;
+}
+/**
+ * `skrr tasks chat send <task-id> --text "..."` — post a message into a Task's
+ * chat (the Task Multi-Turn Conversation surface).
+ *
+ * By default the message joins the current batch and the agent answers when the
+ * batch closes (several messages, one response). `--now` closes the batch and
+ * dispatches in the same request.
+ */
+class TasksChatSend extends base_command_1.BaseCommand {
+    static description = "Send a message into a task's chat";
+    static examples = [
+        '<%= config.bin %> tasks chat send task_abc123 --text "Also cover the retry path"',
+        '<%= config.bin %> tasks chat send OSK-42 --text "Go ahead" --now',
+        '<%= config.bin %> tasks chat send OSK-42 --text "Go ahead" --now --command-id my-retry-key-1',
+    ];
+    static args = {
+        id: core_1.Args.string({ ignoreStdin: true, description: 'Task ID or identifier', required: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        text: core_1.Flags.string({ description: 'Message text', required: true }),
+        now: core_1.Flags.boolean({
+            description: 'Close the batch and dispatch immediately instead of waiting for it to close',
+        }),
+        'command-id': core_1.Flags.string({
+            description: `Actor-scoped command id (${COMMAND_ID_MIN}-${COMMAND_ID_MAX} chars). Reuse it to retry safely; generated fresh when omitted`,
+        }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksChatSend);
+        let body;
+        try {
+            body = buildTaskChatSendBody({
+                text: flags.text,
+                commandId: flags['command-id'],
+                now: flags.now,
+            });
+        }
+        catch (err) {
+            this.error(err.message, { exit: 2 });
+        }
+        const taskId = await this.resolveTaskReference(args.id);
+        let result;
+        try {
+            result = await task_extras_1.taskChatApi.sendExchangeMessage(taskId, body);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ commandId: body.commandId, ...result }, null, 2));
+            return;
+        }
+        this.log(describeSendResult(result));
+    }
+}
+exports.default = TasksChatSend;

package/dist/commands/tasks/checkout.js

@@ -54,10 +54,11 @@ class TasksCheckout extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCheckout);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         const runId = flags.run ?? crypto.randomUUID();
         let result;
         try {
-            result = await data_provider_1.dataService.checkoutTask({ taskId: args.id, runId });
+            result = await data_provider_1.dataService.checkoutTask({ taskId: taskRef, runId });
         }
         catch (err) {
             const e = err;
@@ -73,7 +74,7 @@ class TasksCheckout extends base_command_1.BaseCommand {
             this.log(JSON.stringify(result, null, 2));
             return;
         }
-        this.log(`Checked out task ${args.id} with run ${runId}`);
+        this.log(`Checked out task ${taskRef} with run ${runId}`);
     }
 }
 exports.default = TasksCheckout;

package/dist/commands/tasks/children.js

@@ -20,9 +20,10 @@ class TasksChildren extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksChildren);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let response;
         try {
-            response = await data_provider_1.dataService.listTaskChildren(args.id);
+            response = await data_provider_1.dataService.listTaskChildren(taskRef);
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/tasks/comments/add.js

@@ -128,6 +128,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        const taskRef = await this.resolveEntityRef('task', task.id);
         const commentBody = (0, task_resolver_1.stripTaskIdentityFields)(jsonBody);
         if ('authorAgentId' in commentBody || 'author-agent' in commentBody) {
             this.failWithCliError({
@@ -154,7 +155,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
             for (const filePath of flags.attach) {
                 try {
                     const asset = await uploadTaskAssetFile({
-                        taskId: task.id,
+                        taskId: taskRef,
                         filePath,
                         role: 'evidence',
                     });
@@ -200,7 +201,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
         // ONE key for the original attempt and any later replay — see the comment
         // in `spaces create`. A key sent only on the replay would post a second
         // comment whenever the original landed and its response was lost.
-        const idempotencyKey = (0, outbox_1.idempotencyKeyFor)('task-comment', task.id, JSON.stringify(data));
+        const idempotencyKey = (0, outbox_1.idempotencyKeyFor)('task-comment', taskRef, JSON.stringify(data));
         let result;
         try {
             // apiFetch rather than `dataService.addTaskComment`: the shared transport
@@ -233,7 +234,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
                     },
                     headers: { 'X-Idempotency-Key': idempotencyKey },
                 })
-                : await (0, api_fetch_1.apiFetch)(`/api/tasks/${encodeURIComponent(task.id)}/comments`, {
+                : await (0, api_fetch_1.apiFetch)(`/api/tasks/${encodeURIComponent(taskRef)}/comments`, {
                     method: 'POST',
                     body: data,
                     headers: { 'X-Idempotency-Key': idempotencyKey },
@@ -247,9 +248,9 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
             // different comment on the same task hashes differently and still posts.
             this.queueWriteOrFail(err, {
                 command: 'tasks comments add',
-                summary: `comment on task ${task.id}`,
+                summary: `comment on task ${taskRef}`,
                 method: 'post',
-                url: `/api/tasks/${encodeURIComponent(task.id)}/comments`,
+                url: `/api/tasks/${encodeURIComponent(taskRef)}/comments`,
                 body: data,
                 idempotencyKey,
             });
@@ -264,7 +265,7 @@ class TasksCommentsAdd extends base_command_1.BaseCommand {
             : c.anchor?.commentMarkId
                 ? 'inline comment'
                 : 'comment';
-        this.log(`Added ${kind} ${c.id ?? c._id ?? '?'} on task ${task.id}`);
+        this.log(`Added ${kind} ${c.id ?? c._id ?? '?'} on task ${taskRef}`);
         if (c.anchor?.commentMarkId) {
             this.log(`  anchor markId: ${c.anchor.commentMarkId}`);
             if (c.anchor.quote) {

package/dist/commands/tasks/comments/anchor.js

@@ -228,6 +228,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCommentsAnchor);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         if (flags.occurrence < 1) {
             this.error('--occurrence must be ≥ 1', { exit: 1 });
         }
@@ -244,7 +245,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
         // 1. Fetch current task.
         let task;
         try {
-            task = await data_provider_1.dataService.getTask(args.id, { enrich: false });
+            task = await data_provider_1.dataService.getTask(taskRef, { enrich: false });
         }
         catch (err) {
             this.handleApiError(err);
@@ -275,9 +276,9 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
                 '',
                 'Workarounds:',
                 `  • Edit the description first so the target text lives in one span:`,
-                `      skrr tasks update ${args.id} --description "…"`,
+                `      skrr tasks update ${taskRef} --description "…"`,
                 `  • Or post the anchor without modifying the description:`,
-                `      skrr tasks comments add ${args.id} --body "…" --anchor-quote "…"`,
+                `      skrr tasks comments add ${taskRef} --body "…" --anchor-quote "…"`,
                 '    (the editor will treat the comment as a sticky thread even without',
                 '    a visible span.)',
             ].join('\n'), { exit: 1 });
@@ -304,7 +305,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
             : { description: wrap.html };
         let patched;
         try {
-            patched = await data_provider_1.dataService.updateTask({ taskId: args.id, data: patchData });
+            patched = await data_provider_1.dataService.updateTask({ taskId: taskRef, data: patchData });
         }
         catch (err) {
             const e = err;
@@ -331,7 +332,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
         let comment;
         try {
             comment = await data_provider_1.dataService.addTaskComment({
-                taskId: args.id,
+                taskId: taskRef,
                 data: commentData,
             });
         }
@@ -343,7 +344,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
             // our PATCH and rollback, we accept that they win and warn the user.
             try {
                 await data_provider_1.dataService.updateTask({
-                    taskId: args.id,
+                    taskId: taskRef,
                     data: { description: originalDescription },
                 });
                 this.warn('Comment POST failed — rolled back description to its pre-anchor state.');
@@ -361,7 +362,7 @@ class TasksCommentsAnchor extends base_command_1.BaseCommand {
             return;
         }
         const c = comment;
-        this.log(`Anchored comment ${c.id ?? c._id ?? '?'} on task ${args.id}`);
+        this.log(`Anchored comment ${c.id ?? c._id ?? '?'} on task ${taskRef}`);
         this.log(`  mark id: ${markId}`);
         this.log(`  match:   occurrence ${wrap.occurrence} of ${wrap.totalMatches}`);
         this.log(`  quote:   "${quote.length > 80 ? quote.slice(0, 77) + '…' : quote}"`);

package/dist/commands/tasks/comments/delete.js

@@ -20,9 +20,10 @@ class TasksCommentsDelete extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCommentsDelete);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let confirmed;
         try {
-            confirmed = await (0, prompt_1.confirmDestructive)(`Delete comment ${args.commentId} from task ${args.id}? This cannot be undone.`, flags.yes);
+            confirmed = await (0, prompt_1.confirmDestructive)(`Delete comment ${args.commentId} from task ${taskRef}? This cannot be undone.`, flags.yes);
         }
         catch (err) {
             const e = err;
@@ -33,7 +34,7 @@ class TasksCommentsDelete extends base_command_1.BaseCommand {
             return;
         }
         try {
-            await data_provider_1.dataService.deleteTaskComment({ taskId: args.id, commentId: args.commentId });
+            await data_provider_1.dataService.deleteTaskComment({ taskId: taskRef, commentId: args.commentId });
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/tasks/comments/list.js

@@ -83,9 +83,10 @@ class TasksCommentsList extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        const taskRef = await this.resolveEntityRef('task', task.id);
         let response;
         try {
-            response = await data_provider_1.dataService.listTaskComments(task.id, {
+            response = await data_provider_1.dataService.listTaskComments(taskRef, {
                 limit: flags.limit,
                 cursor: flags.cursor,
             });

package/dist/commands/tasks/comments/reopen.js

@@ -19,10 +19,11 @@ class TasksCommentsReopen extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCommentsReopen);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let result;
         try {
             result = await data_provider_1.dataService.reopenTaskComment({
-                taskId: args.id,
+                taskId: taskRef,
                 commentId: args.commentId,
             });
         }
@@ -34,7 +35,7 @@ class TasksCommentsReopen extends base_command_1.BaseCommand {
             return;
         }
         const c = result;
-        this.log(`Reopened comment ${c.id ?? c._id ?? args.commentId} on task ${args.id}`);
+        this.log(`Reopened comment ${c.id ?? c._id ?? args.commentId} on task ${taskRef}`);
     }
 }
 exports.default = TasksCommentsReopen;

package/dist/commands/tasks/comments/resolve.js

@@ -19,10 +19,11 @@ class TasksCommentsResolve extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksCommentsResolve);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let result;
         try {
             result = await data_provider_1.dataService.resolveTaskComment({
-                taskId: args.id,
+                taskId: taskRef,
                 commentId: args.commentId,
             });
         }
@@ -34,7 +35,7 @@ class TasksCommentsResolve extends base_command_1.BaseCommand {
             return;
         }
         const c = result;
-        this.log(`Resolved comment ${c.id ?? c._id ?? args.commentId} on task ${args.id}`);
+        this.log(`Resolved comment ${c.id ?? c._id ?? args.commentId} on task ${taskRef}`);
     }
 }
 exports.default = TasksCommentsResolve;