@skrr-ai/cli 0.1.92 → 0.1.94

package/dist/commands/tasks/create-tree.js

@@ -1,12 +1,89 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.unkeyedNodes = unkeyedNodes;
+exports.rerunWarning = rerunWarning;
+exports.derivedTreePrefix = derivedTreePrefix;
+exports.derivedPrefixWarning = derivedPrefixWarning;
+exports.partialFailureResult = partialFailureResult;
 exports.normalizeTreeRoots = normalizeTreeRoots;
 exports.planTree = planTree;
 const core_1 = require("@oclif/core");
+const node_crypto_1 = require("node:crypto");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
 const prompt_1 = require("../../lib/prompt");
+const task_batch_1 = require("../../lib/task-batch");
 const tasks_1 = require("../../lib/tasks");
+/**
+ * Nodes a re-run could not recognize: no externalKey of their own and no
+ * `--external-key-prefix` to derive one. Re-running a partly applied tree
+ * creates these twice.
+ */
+function unkeyedNodes(planned) {
+    return planned
+        .filter(({ payload }) => !(typeof payload.externalKey === 'string' && payload.externalKey.trim()))
+        .map(({ key }) => key);
+}
+function rerunWarning(planned, prefix) {
+    const unkeyed = unkeyedNodes(planned);
+    if (unkeyed.length === 0)
+        return undefined;
+    return {
+        code: 'TREE_RERUN_NOT_IDEMPOTENT',
+        value: unkeyed,
+        hint: `${unkeyed.length} node(s) have no externalKey${prefix ? '' : ' and no --external-key-prefix was given'}, ` +
+            'so re-running this tree after a failure would create them again. Pass --external-key-prefix <stable-prefix> ' +
+            '(or an externalKey per node) to make a re-run update instead of duplicate.',
+    };
+}
+/**
+ * A key prefix derived from the tree itself (its JSON plus the default scope),
+ * stable across runs: the same file into the same space always names the same
+ * keys. Different content or a different default space is a different prefix.
+ */
+function derivedTreePrefix(input, defaults) {
+    const digest = (0, node_crypto_1.createHash)('sha256')
+        .update((0, data_provider_1.stableJson)({ input, defaults }))
+        .digest('hex')
+        .slice(0, 12);
+    return `tree-${digest}`;
+}
+function derivedPrefixWarning(prefix) {
+    return {
+        code: 'TREE_PREFIX_DERIVED',
+        value: prefix,
+        hint: `No --external-key-prefix was given, so nodes are keyed "${prefix}/<tempId>" from the file's content: ` +
+            're-running the same file updates these tasks instead of creating copies. Pass --fresh to create a second copy, ' +
+            'or --external-key-prefix to choose your own keys.',
+    };
+}
+/**
+ * What a half-applied tree reports (E4). The ids already created are the only
+ * way to continue or clean up, and the failing call used to print none of them.
+ */
+function partialFailureResult(args) {
+    const { results, mapping, failedAt, total, prefix, warnings } = args;
+    return {
+        object: 'task_create_tree_result',
+        ok: false,
+        count: results.length,
+        total,
+        created: results.map((r) => ({
+            tempId: r.tempId,
+            parentTempId: r.parentTempId,
+            id: r.id,
+            action: r.action,
+            externalKey: r.externalKey,
+            title: r.title,
+        })),
+        mapping,
+        failedAt,
+        rerun: prefix
+            ? 'Safe to re-run the same command: nodes with an externalKey are updated, not duplicated.'
+            : 'Re-running creates un-keyed nodes again. Use mapping to continue by hand, or re-run with --external-key-prefix.',
+        ...(warnings.length > 0 ? { warnings } : {}),
+    };
+}
 class TasksCreateTree extends base_command_1.BaseCommand {
     static description = 'Create a task tree from JSON. Use {"nodes":[{"tempId":"root","title":"Task","executionMode":"human","assigneeUserIds":["<user-id>"]}]} to avoid inheriting a Space lead agent.';
     static examples = [
@@ -23,7 +100,10 @@ class TasksCreateTree extends base_command_1.BaseCommand {
         }),
         'dry-run': core_1.Flags.boolean({ description: 'Validate and print the plan without creating tasks' }),
         'external-key-prefix': core_1.Flags.string({
-            description: 'Generate externalKey for nodes that omit one; enables idempotent re-runs',
+            description: 'Generate externalKey for nodes that omit one; enables idempotent re-runs. Defaults to a prefix derived from the file content (see --fresh)',
+        }),
+        fresh: core_1.Flags.boolean({
+            description: 'Do not derive a key prefix from the file: create a new copy even if this exact file was applied before',
         }),
         'default-agent': core_1.Flags.string({
             description: 'Override the automatic assignee for nodes with no assignee. Use "auto" to inherit the space lead agent; children inherit parent assignees first.',
@@ -49,9 +129,15 @@ class TasksCreateTree extends base_command_1.BaseCommand {
             this.error(err.message, { exit: 1 });
         }
         const topLevelDefaults = normalizeDefaults(input, flags);
+        // E4: with no prefix of its own, a tree is keyed from its content, so
+        // re-running the same file after a failure updates instead of duplicating.
+        const derivedPrefix = flags['external-key-prefix'] || flags.fresh
+            ? undefined
+            : derivedTreePrefix(input, topLevelDefaults);
+        const keyPrefix = flags['external-key-prefix'] ?? derivedPrefix;
         const planned = planTree(roots, {
             defaults: topLevelDefaults,
-            externalKeyPrefix: flags['external-key-prefix'],
+            externalKeyPrefix: keyPrefix,
         });
         const defaultAgentErrors = [];
         const defaultAgentResolutions = {};
@@ -142,6 +228,13 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                 object: 'task_create_tree_dry_run',
                 ok: true,
                 count: planned.length,
+                ...(() => {
+                    const dryWarnings = [
+                        rerunWarning(planned, keyPrefix),
+                        derivedPrefix ? derivedPrefixWarning(derivedPrefix) : undefined,
+                    ].filter((w) => w !== undefined);
+                    return dryWarnings.length > 0 ? { warnings: dryWarnings } : {};
+                })(),
                 defaultAgents: defaultAgentResolutions,
                 nodes: planned.map((item) => ({
                     tempId: item.key,
@@ -161,9 +254,49 @@ class TasksCreateTree extends base_command_1.BaseCommand {
             }
             return;
         }
+        const treeWarning = rerunWarning(planned, keyPrefix);
+        const derivedWarning = derivedPrefix ? derivedPrefixWarning(derivedPrefix) : undefined;
+        const warnings = [
+            ...(treeWarning ? [treeWarning] : []),
+            ...(derivedWarning ? [derivedWarning] : []),
+        ];
+        if (treeWarning && !flags.json)
+            process.stderr.write(`Warning: ${treeWarning.hint}\n`);
+        if (derivedWarning && !flags.json)
+            process.stderr.write(`Note: ${derivedWarning.hint}\n`);
         const mapping = {};
         const results = [];
-        for (const item of planned) {
+        // A half-applied tree reports the ids it did create; the only way back.
+        const reportPartial = (item, failure, err) => {
+            if (results.length === 0)
+                this.handleApiError(err);
+            const partial = partialFailureResult({
+                results,
+                mapping,
+                total: planned.length,
+                prefix: keyPrefix,
+                warnings,
+                failedAt: {
+                    tempId: item.key,
+                    ...(item.parentKey ? { parentTempId: item.parentKey } : {}),
+                    title: item.payload.title,
+                    error: failure,
+                },
+            });
+            if (flags.json) {
+                this.log(JSON.stringify(partial, null, 2));
+                process.exitCode = partial.failedAt.error.retryable ? 5 : 1;
+                this.exit(partial.failedAt.error.retryable ? 5 : 1);
+            }
+            this.log(`Created ${results.length} of ${planned.length} task(s) before "${item.key}" failed:`);
+            for (const [tempId, id] of Object.entries(mapping))
+                this.log(`- ${tempId} -> ${id}`);
+            this.log(partial.rerun);
+            this.handleApiError(err);
+        };
+        // The serial path: one request per node. Used for updates of existing keyed
+        // nodes, and for every create against a server without the batch route.
+        const applySerial = async (item) => {
             const payload = { ...item.payload };
             if (item.parentKey) {
                 payload.parentId = mapping[item.parentKey];
@@ -197,7 +330,8 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                 }
             }
             catch (err) {
-                this.handleApiError(err);
+                reportPartial(item, (0, task_batch_1.describeApiFailure)(err), err);
+                return;
             }
             const id = (0, tasks_1.taskId)(task);
             mapping[item.key] = id;
@@ -210,9 +344,68 @@ class TasksCreateTree extends base_command_1.BaseCommand {
                 title: task.title ?? payload.title,
                 task,
             });
+        };
+        // New nodes go to POST /api/tasks/batch in chunks. `batchAvailable` flips off
+        // the first time the server answers 404/405, and every later node is serial.
+        let batchAvailable = true;
+        let pending = [];
+        const flushPending = async () => {
+            const nodes = pending;
+            pending = [];
+            if (nodes.length === 0)
+                return;
+            if (batchAvailable) {
+                const outcome = await (0, task_batch_1.createNodesViaBatch)(nodes.map((n) => ({ key: n.key, parentKey: n.parentKey, payload: n.payload })), mapping);
+                if (outcome.supported) {
+                    const byKey = new Map(nodes.map((n) => [n.key, n]));
+                    for (const row of outcome.rows) {
+                        const node = byKey.get(row.key);
+                        results.push({
+                            tempId: row.key,
+                            parentTempId: node.parentKey,
+                            id: row.id,
+                            action: row.status === 'exists' ? 'existing' : 'created',
+                            externalKey: row.externalKey ?? node.payload.externalKey,
+                            title: node.payload.title,
+                            task: {
+                                id: row.id,
+                                ...(row.identifier ? { identifier: row.identifier } : {}),
+                                title: node.payload.title,
+                            },
+                        });
+                    }
+                    const failure = outcome.failures.find((f) => !f.skipped) ?? outcome.failures[0];
+                    if (failure) {
+                        const node = byKey.get(failure.key);
+                        const err = Object.assign(new Error(failure.error.message), {
+                            ...(failure.error.status ? { status: failure.error.status } : {}),
+                            ...(failure.error.code ? { code: failure.error.code } : {}),
+                        });
+                        reportPartial(node, failure.error, err);
+                    }
+                    return;
+                }
+                batchAvailable = false;
+            }
+            for (const node of nodes)
+                await applySerial(node);
+        };
+        for (const item of planned) {
+            const existingTask = existingByKey.get(item.key) ?? null;
+            if (existingTask) {
+                // An update must see its parent's id, and a later create its own parent's.
+                await flushPending();
+                await applySerial(item);
+            }
+            else {
+                pending.push(item);
+            }
         }
+        await flushPending();
         const summary = {
             object: 'task_create_tree_result',
+            ok: true,
+            ...(warnings.length > 0 ? { warnings } : {}),
             count: results.length,
             defaultAgents: defaultAgentResolutions,
             mapping,

package/dist/commands/tasks/delete.js

@@ -24,9 +24,10 @@ class TasksDelete extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksDelete);
+        const taskId = await this.resolveEntityRef('task', args.id);
         let confirmed;
         try {
-            confirmed = await (0, prompt_1.confirmDestructive)(`Delete task ${args.id}? This cannot be undone.`, flags.yes);
+            confirmed = await (0, prompt_1.confirmDestructive)(`Delete task ${taskId === args.id ? taskId : `${args.id} (${taskId})`}? This cannot be undone.`, flags.yes);
         }
         catch (err) {
             if (err.exit === 7) {
@@ -36,18 +37,18 @@ class TasksDelete extends base_command_1.BaseCommand {
         }
         if (!confirmed) {
             if (flags.json)
-                return this.log(JSON.stringify({ deleted: false, id: args.id }, null, 2));
+                return this.log(JSON.stringify({ deleted: false, id: taskId }, null, 2));
             this.log('Cancelled.');
             return;
         }
         try {
-            await data_provider_1.dataService.deleteTask(args.id);
+            await data_provider_1.dataService.deleteTask(taskId);
         }
         catch (err) {
             this.handleApiError(err);
         }
         if (flags.json)
-            return this.log(JSON.stringify({ deleted: true, id: args.id }, null, 2));
+            return this.log(JSON.stringify({ deleted: true, id: taskId }, null, 2));
         this.log(`Deleted task ${args.id}`);
     }
 }

package/dist/commands/tasks/descendants.js

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

package/dist/commands/tasks/dri-plan.js

@@ -18,9 +18,10 @@ class TasksDriPlan extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksDriPlan);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let result;
         try {
-            result = await data_provider_1.dataService.startDRIPlan(args.id);
+            result = await data_provider_1.dataService.startDRIPlan(taskRef);
         }
         catch (err) {
             this.handleApiError(err);
@@ -29,7 +30,7 @@ class TasksDriPlan extends base_command_1.BaseCommand {
             this.log(JSON.stringify(result, null, 2));
             return;
         }
-        this.log(`Started DRI plan for task ${args.id}`);
+        this.log(`Started DRI plan for task ${taskRef}`);
         const r = result;
         if (r.conversationId)
             this.log(`Conversation: ${r.conversationId}`);

package/dist/commands/tasks/dri-run.js

@@ -18,9 +18,10 @@ class TasksDriRun extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksDriRun);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let result;
         try {
-            result = await data_provider_1.dataService.startDRIAgent(args.id);
+            result = await data_provider_1.dataService.startDRIAgent(taskRef);
         }
         catch (err) {
             this.handleApiError(err);
@@ -29,7 +30,7 @@ class TasksDriRun extends base_command_1.BaseCommand {
             this.log(JSON.stringify(result, null, 2));
             return;
         }
-        this.log(`Started DRI run for task ${args.id}`);
+        this.log(`Started DRI run for task ${taskRef}`);
         const r = result;
         if (r.conversationId)
             this.log(`Conversation: ${r.conversationId}`);

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

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

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

@@ -22,6 +22,7 @@ class TasksDuplicatePipeline extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksDuplicatePipeline);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         const data = {};
         if (flags.title)
             data.title = flags.title;
@@ -29,7 +30,7 @@ class TasksDuplicatePipeline extends base_command_1.BaseCommand {
             data.description = flags.description;
         let result;
         try {
-            result = await data_provider_1.dataService.duplicatePipeline(args.id, Object.keys(data).length > 0 ? data : undefined);
+            result = await data_provider_1.dataService.duplicatePipeline(taskRef, Object.keys(data).length > 0 ? data : undefined);
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/tasks/execution-summary.js

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

package/dist/commands/tasks/execution-timeline.js

@@ -22,10 +22,11 @@ class TasksExecutionTimeline extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksExecutionTimeline);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         const limit = Math.min(flags.limit, 500);
         let response;
         try {
-            response = await data_provider_1.dataService.getTaskExecutionTimeline(args.id, flags.run, limit);
+            response = await data_provider_1.dataService.getTaskExecutionTimeline(taskRef, flags.run, limit);
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/tasks/fork.js

@@ -70,6 +70,7 @@ class TasksFork extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        const taskRef = await this.resolveEntityRef('task', taskIdentity.id);
         const taskId = taskIdentity.id;
         // The branch agent is OPTIONAL — a fork onto the same agent on a different
         // target is the "try it on Codex too" case, and the server derives the

package/dist/commands/tasks/forward.js

@@ -28,6 +28,7 @@ class TasksForward extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksForward);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         // Server dedupes ids, but trimming here keeps the audit log readable.
         const groupChatIds = Array.from(new Set(flags.to.map((id) => id.trim()).filter(Boolean)));
         if (groupChatIds.length === 0) {
@@ -35,7 +36,7 @@ class TasksForward extends base_command_1.BaseCommand {
         }
         let result;
         try {
-            result = await data_provider_1.dataService.forwardTask(args.id, {
+            result = await data_provider_1.dataService.forwardTask(taskRef, {
                 groupChatIds,
                 note: flags.note,
             });
@@ -46,13 +47,13 @@ class TasksForward extends base_command_1.BaseCommand {
         if (flags.json) {
             this.log(JSON.stringify({
                 ...result,
-                url: (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: args.id }),
+                url: (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, { id: taskRef }),
             }, null, 2));
             return;
         }
         const posted = result.posted ?? [];
         const failed = result.failed ?? [];
-        this.log(`Forwarded task ${args.id} → ${posted.length} chat(s)`);
+        this.log(`Forwarded task ${taskRef} → ${posted.length} chat(s)`);
         for (const p of posted) {
             this.log(`  posted   ${p.groupChatId}  (message ${p.messageId})`);
         }

package/dist/commands/tasks/handover.js

@@ -99,6 +99,7 @@ class TasksHandover extends base_command_1.BaseCommand {
                 details: { suggestion: failure.suggestion, context: failure.details },
             });
         }
+        const taskRef = await this.resolveEntityRef('task', taskIdentity.id);
         const taskId = taskIdentity.id;
         // ── Target agent: id or name, resolved like `code handover --to`. ──────
         let agents = [];

package/dist/commands/tasks/interrupt.js

@@ -28,11 +28,12 @@ class TasksInterrupt extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksInterrupt);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         const body = (flags.reason && flags.reason.trim()) || 'Execution interrupted by user.';
         let result;
         try {
             result = await data_provider_1.dataService.addTaskComment({
-                taskId: args.id,
+                taskId: taskRef,
                 data: { body, interrupt: true },
             });
         }
@@ -44,7 +45,7 @@ class TasksInterrupt extends base_command_1.BaseCommand {
             return;
         }
         const c = result;
-        this.log(`Interrupt sent to task ${args.id} (comment ${c.id ?? c._id ?? '?'})`);
+        this.log(`Interrupt sent to task ${taskRef} (comment ${c.id ?? c._id ?? '?'})`);
     }
 }
 exports.default = TasksInterrupt;

package/dist/commands/tasks/labels/attach.js

@@ -40,6 +40,7 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksLabelsAttach);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         const refs = (flags['label-id'] ?? []).map((id) => id.trim()).filter((id) => id.length > 0);
         if (refs.length === 0) {
             this.error('At least one --label-id is required.', { exit: 1 });
@@ -74,7 +75,7 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
         const nameFor = (id) => nameById?.get(id) ?? id;
         let current;
         try {
-            current = await data_provider_1.dataService.getTask(args.id, { enrich: false });
+            current = await data_provider_1.dataService.getTask(taskRef, { enrich: false });
         }
         catch (err) {
             this.handleApiError(err);
@@ -93,7 +94,7 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
         let updated;
         try {
             updated = await data_provider_1.dataService.updateTask({
-                taskId: args.id,
+                taskId: taskRef,
                 data: { labelIds: merged },
             });
         }
@@ -106,7 +107,7 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
         }
         const t = updated;
         const ref = t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '');
-        this.log(`Attached ${merged.length - existing.length} label(s) to task ${t.id ?? args.id}${ref ? ` (${ref})` : ''} — now: ${merged.map(nameFor).join(', ')}`);
+        this.log(`Attached ${merged.length - existing.length} label(s) to task ${t.id ?? taskRef}${ref ? ` (${ref})` : ''} — now: ${merged.map(nameFor).join(', ')}`);
     }
 }
 exports.default = TasksLabelsAttach;

package/dist/commands/tasks/labels/detach.js

@@ -32,6 +32,7 @@ class TasksLabelsDetach extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksLabelsDetach);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         const refs = (flags['label-id'] ?? []).map((id) => id.trim()).filter((id) => id.length > 0);
         if (refs.length === 0) {
             this.error('At least one --label-id is required.', { exit: 1 });
@@ -55,7 +56,7 @@ class TasksLabelsDetach extends base_command_1.BaseCommand {
         const targets = new Set(resolvedTargets);
         let current;
         try {
-            current = await data_provider_1.dataService.getTask(args.id, { enrich: false });
+            current = await data_provider_1.dataService.getTask(taskRef, { enrich: false });
         }
         catch (err) {
             this.handleApiError(err);
@@ -71,7 +72,7 @@ class TasksLabelsDetach extends base_command_1.BaseCommand {
         let updated;
         try {
             updated = await data_provider_1.dataService.updateTask({
-                taskId: args.id,
+                taskId: taskRef,
                 data: { labelIds: next },
             });
         }
@@ -84,7 +85,7 @@ class TasksLabelsDetach extends base_command_1.BaseCommand {
         }
         const t = updated;
         const ref = t.identifier ?? (t.taskNumber ? `#${t.taskNumber}` : '');
-        this.log(`Detached ${existing.length - next.length} label(s) from task ${t.id ?? args.id}${ref ? ` (${ref})` : ''} — now: ${next.join(', ') || '(none)'}`);
+        this.log(`Detached ${existing.length - next.length} label(s) from task ${t.id ?? taskRef}${ref ? ` (${ref})` : ''} — now: ${next.join(', ') || '(none)'}`);
     }
 }
 exports.default = TasksLabelsDetach;

package/dist/commands/tasks/labels/suggest.js

@@ -31,11 +31,12 @@ class TasksLabelsSuggest extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksLabelsSuggest);
+        const taskRef = await this.resolveEntityRef('task', args.id);
         let response;
         try {
             // The URL lives in the lib — a command that builds its own `/api/...`
             // string is invisible to the CLI↔API parity check.
-            response = await (0, task_extras_1.taskLabelSuggestion)(args.id);
+            response = await (0, task_extras_1.taskLabelSuggestion)(taskRef);
         }
         catch (err) {
             this.handleApiError(err);
@@ -47,7 +48,7 @@ class TasksLabelsSuggest extends base_command_1.BaseCommand {
         const suggestions = (response?.suggestions ?? []).filter((s) => Boolean(s?.id && s?.name));
         const ref = response?.identifier ? ` (${response.identifier})` : '';
         if (suggestions.length === 0) {
-            this.log(`No label suggestions for task ${args.id}${ref} — ` +
+            this.log(`No label suggestions for task ${taskRef}${ref} — ` +
                 // The server counts the vocabulary AFTER excluding the labels this
                 // task already wears, so 0 means nothing left to propose, not that
                 // the registry is empty.
@@ -57,13 +58,13 @@ class TasksLabelsSuggest extends base_command_1.BaseCommand {
                 ' "No label" is a correct answer.');
             return;
         }
-        this.log(`Suggested labels for task ${args.id}${ref}:`);
+        this.log(`Suggested labels for task ${taskRef}${ref}:`);
         (0, format_1.renderTable)(suggestions.map((s) => ({ id: s.id, name: s.name })), [
             { key: 'id', header: 'ID' },
             { key: 'name', header: 'NAME' },
         ], (line) => this.log(line));
         this.log(`A suggestion is a proposal, not a write — attach with ` +
-            `\`skrr tasks labels attach ${args.id} --label <id>\` if one fits.`);
+            `\`skrr tasks labels attach ${taskRef} --label <id>\` if one fits.`);
     }
 }
 exports.default = TasksLabelsSuggest;

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

@@ -1,6 +1,21 @@
 import type { TaskListParams } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../base-command';
+import { type ListWarning } from '../../lib/list-output';
 type ListFlags = Record<string, unknown>;
+/**
+ * E12: inside an agent session an unfiltered `tasks list --json` returned the
+ * first page of EVERYTHING, which in practice was cancelled test tasks. When the
+ * caller is an agent (a session agent id in the environment) asking for machine
+ * output and has named no state filter of its own, default to open work and SAY
+ * so, as data (`filter_applied`) and not only in prose. `--all` is the opt-out;
+ * any filter the caller wrote leaves the default off, since they have decided.
+ * A person at a terminal is untouched.
+ */
+export declare function agentSessionOpenDefault(flags: ListFlags, env?: NodeJS.ProcessEnv): {
+    open: true;
+    reason: 'agent_session_default';
+    hint: string;
+} | undefined;
 /**
  * What the zero-row case is allowed to say. The bare `No tasks.` was step 3
  * of `GETTING_STARTED.md` and named no next step; a new user reading it hit
@@ -31,10 +46,21 @@ export declare function taskRef(t: Record<string, unknown>): string;
  * the command; this function is deliberately pure for reuse and parity tests.
  */
 export declare function buildListParams(flags: ListFlags, assigneeUserId?: string): TaskListParams;
+/**
+ * P4: `--status bogus` exits 0 with an empty list, and text mode explains why
+ * while `--json` said nothing, so an agent could not tell "no matches" from
+ * "invalid filter". Same facts, as data.
+ */
+export declare function statusFilterWarnings(flags: ListFlags, rowCount: number): ListWarning[];
 export default class TasksList extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        strict: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        calendar: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        fields: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        compact: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        ndjson: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         space: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         goal: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
@@ -75,7 +101,7 @@ export default class TasksList extends BaseCommand {
         view: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         limit: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
         cursor: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        calendar: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }