@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/tasks/expectations/assess.js

@@ -41,21 +41,70 @@ class TasksExpectationsAssess extends base_command_1.BaseCommand {
         }),
         'spec-version': core_1.Flags.integer({ description: 'Task specification version being assessed' }),
         'idempotency-key': core_1.Flags.string({ description: 'Stable retry key' }),
+        all: core_1.Flags.boolean({
+            description: 'Assess every Expectation still awaiting one on this Task, with the same decision ' +
+                'and reason. Already-settled Expectations are left alone, and ones already judged ' +
+                'unmet are skipped unless --include-unmet.',
+        }),
+        'include-unmet': core_1.Flags.boolean({
+            description: 'With --all, also re-assess Expectations somebody judged unmet — for after the work ' +
+                'was fixed. Overwrites a considered rejection, so it is never implied.',
+        }),
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
     };
+    /**
+     * Which Expectations `--all` covers.
+     *
+     * ONLY the ones nothing has settled. An already-assessed Expectation carries
+     * somebody's judgement, and a bulk pass that overwrote it would silently
+     * replace a considered `unmet` with a blanket `met` — which is the one thing a
+     * batch verb must never do. Overriding an existing assessment stays a
+     * deliberate, single, named act.
+     */
+    async awaitingIds(taskId, { includeUnmet = false } = {}) {
+        const acceptance = await data_provider_1.dataService.getTaskAcceptance(taskId);
+        const gatingUnsettled = acceptance.expectations.filter((expectation) => expectation.gating && !expectation.met);
+        /*
+         * A row somebody judged `unmet` is SKIPPED by default and NAMED either way.
+         *
+         * Skipping is right: a blanket `--all --decision met` that swept up a
+         * reviewer's considered "no" is the one thing a batch verb must never do.
+         * Saying nothing about it was not: the row displayed as "needs assessment"
+         * (it no longer does), `--all` reported the Task settled, and the board
+         * could never be cleared because the only bulk verb silently declined to
+         * touch the only rows left.
+         */
+        const rejected = gatingUnsettled
+            .filter((expectation) => expectation.state === 'unmet')
+            .map((expectation) => expectation.id);
+        const ids = gatingUnsettled
+            .filter((expectation) => !expectation.assessmentId || (includeUnmet && expectation.state === 'unmet'))
+            .map((expectation) => expectation.id);
+        return { ids, rejected };
+    }
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksExpectationsAssess);
         // `assess <task> <expectation>` gives both; `assess <expectation>` inside a
         // task runtime gives one, and it is the Expectation.
         const expectationId = args.expectation ?? args.task;
-        if (!expectationId) {
-            this.error('An Expectation id is required: `tasks expectations assess <task> <expectation>`', {
+        if (!expectationId && !flags.all) {
+            this.error('An Expectation id is required: `tasks expectations assess <task> <expectation>`, ' +
+                'or pass --all to settle every Expectation still awaiting one.', {
                 exit: 1,
             });
         }
+        /*
+         * Which positional is the TASK.
+         *
+         * `assess <task> <expectation>` gives both, so the first is the Task.
+         * `assess <expectation>` inside a task runtime gives one, and it is the
+         * Expectation — there is no Task positional to read. With `--all` there is
+         * no Expectation to name at all, so a lone positional is the Task again.
+         */
+        const taskPositional = flags.all || args.expectation ? args.task : undefined;
         const task = (0, task_resolver_1.resolveTaskIdentity)({
-            positionalId: args.expectation ? args.task : undefined,
+            positionalId: taskPositional,
             flagTask: flags.task,
         });
         const evidenceRefs = (flags.evidence || []).map((raw) => {
@@ -75,22 +124,82 @@ class TasksExpectationsAssess extends base_command_1.BaseCommand {
             evidenceRefs,
             expectedSpecVersion: flags['spec-version'],
         };
-        let result;
-        try {
+        const reuseCallerKey = Boolean(flags['idempotency-key']) && !flags.all;
+        const submit = async (id) => {
             const data = {
                 ...payload,
-                expectationId,
-                idempotencyKey: flags['idempotency-key'] ||
-                    (0, outbox_1.idempotencyKeyFor)('task-expectation-assessment', task.id, JSON.stringify({ expectationId, ...payload })),
+                expectationId: id,
+                // A per-expectation key under `--all`: one caller-supplied key reused
+                // across the set would make the second write a duplicate of the first,
+                // settling exactly one Expectation while reporting several.
+                idempotencyKey: reuseCallerKey
+                    ? flags['idempotency-key']
+                    : (0, outbox_1.idempotencyKeyFor)('task-expectation-assessment', task.id, JSON.stringify({ expectationId: id, ...payload })),
             };
             const sessionPath = await (0, session_task_endpoints_1.sessionScopedTaskPath)('assessment');
-            result = sessionPath
+            return sessionPath
                 ? await (0, api_fetch_1.apiFetch)(sessionPath, { method: 'POST', body: data })
-                : await data_provider_1.dataService.assessTaskExpectation({
-                    taskId: task.id,
-                    expectationId,
-                    data,
-                });
+                : await data_provider_1.dataService.assessTaskExpectation({ taskId: task.id, expectationId: id, data });
+        };
+        if (flags.all) {
+            let ids;
+            let rejected;
+            try {
+                ({ ids, rejected } = await this.awaitingIds(task.id, {
+                    includeUnmet: flags['include-unmet'],
+                }));
+            }
+            catch (error) {
+                this.handleApiError(error);
+                return;
+            }
+            const skippedRejections = flags['include-unmet'] ? [] : rejected;
+            if (ids.length === 0) {
+                if (skippedRejections.length > 0) {
+                    // "Nothing is awaiting assessment" was true of what this command
+                    // WOULD touch and false about the Task, which is the distinction that
+                    // made the board unclearable.
+                    this.log(`Nothing is awaiting a first assessment, but ${skippedRejections.length} ` +
+                        `Expectation(s) were judged unmet: ${skippedRejections.join(', ')}.`);
+                    this.log(`Fix the work and re-assess ${skippedRejections.length === 1 ? 'it' : 'them'} by id, ` +
+                        'or re-run with --include-unmet to overwrite the rejection.');
+                    return;
+                }
+                this.log('Nothing is awaiting assessment on this Task.');
+                return;
+            }
+            if (skippedRejections.length > 0) {
+                this.log(`Skipping ${skippedRejections.length} Expectation(s) judged unmet ` +
+                    `(${skippedRejections.join(', ')}) — pass --include-unmet to re-assess them.`);
+            }
+            // Each write is reported on its own. A partial failure must leave the
+            // caller knowing exactly which Expectations were settled, because the
+            // remedy is to re-run for the rest — a single rolled-up "failed" would
+            // make that impossible to work out.
+            const settled = [];
+            const failed = [];
+            for (const id of ids) {
+                try {
+                    await submit(id);
+                    settled.push(id);
+                }
+                catch (error) {
+                    failed.push({ id, message: error?.message || 'unknown error' });
+                }
+            }
+            if (flags.json) {
+                return this.log(JSON.stringify({ decision: flags.decision, settled, failed }, null, 2));
+            }
+            this.log(`Recorded ${settled.length} Expectation(s) as ${flags.decision}: ${settled.join(', ')}`);
+            for (const failure of failed)
+                this.log(`  FAILED ${failure.id}: ${failure.message}`);
+            if (failed.length > 0)
+                this.exit(1);
+            return;
+        }
+        let result;
+        try {
+            result = await submit(expectationId);
         }
         catch (error) {
             this.handleApiError(error);

package/dist/commands/tasks/expectations.js

@@ -4,6 +4,8 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const data_provider_2 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../base-command");
+const data_provider_3 = require("@skrr-ai/data-provider");
+const task_closure_1 = require("../../lib/task-closure");
 /**
  * `skrr tasks expectations <task>` — what this task owes, and how far each got.
  *
@@ -12,18 +14,21 @@ const base_command_1 = require("../../base-command");
  * could disagree with the gate that refuses the task — and the reader would
  * have no way to tell which was lying.
  */
-const STATE_LABEL = {
-    met: 'done',
-    waived: 'dropped',
-    blocked: 'stuck',
-    // Its own word, because its next action is its own: somebody looks, rather
-    // than somebody works. Reading it as 'not yet' sends people to redo finished
-    // work, which is precisely the confusion the state was added to remove.
-    unverified: 'needs a look',
-    underway: 'on its way',
-    owed: 'not yet',
-    unassessed: 'needs assessment',
-};
+/*
+ * The labels come from `@skrr-ai/data-provider`, not from here.
+ *
+ * This file said `dropped` where the user had typed `waived` and `done` where
+ * they had typed `met`; the web said `Waived` and `Met`; and an unjudged row
+ * read as `not yet` in one column and `needs assessment` in the trailer. Three
+ * spellings of one vocabulary is how a user stops trusting that the word they
+ * wrote is the word that was stored.
+ *
+ * A state derived from a DECISION now reads back as that decision's own word.
+ * `owed` and `unassessed` stay distinct — "nobody produced it" and "nobody
+ * judged it" are different next actions — and the legend below says so, which
+ * the near-synonymous English never could on its own.
+ */
+const STATE_LABEL = data_provider_3.EXPECTATION_STATE_LABEL;
 /**
  * The evidence gap, on the rows where a reader can act on it.
  *
@@ -62,8 +67,26 @@ function evidenceGap(expectation) {
         return '';
     return `  (has ${expectation.evidenceLevel}, needs ${expectation.requiredEvidence})`;
 }
+/**
+ * `done (agent)` rather than `done`.
+ *
+ * An agent may assess any Expectation, so the control that keeps this honest is
+ * not permission — it is that a reader can always see whose judgement closed a
+ * row and decide how much to trust it. Printed only on rows an assessment
+ * actually settled; a state derived from the deliverable ledger has no assessor
+ * and must not be given a fake one.
+ */
+function assessorSuffix(expectation) {
+    if (!expectation.assessedByKind)
+        return '';
+    // `unmet` joins them: a rejection is a judgement, and whose it was matters at
+    // least as much as whose `met` it was.
+    if (!['met', 'waived', 'unmet'].includes(expectation.state))
+        return '';
+    return ` (${(0, task_closure_1.describeAssessor)(expectation.assessedByKind)})`;
+}
 function line(expectation) {
-    const label = STATE_LABEL[expectation.state] || expectation.state;
+    const label = (STATE_LABEL[expectation.state] || expectation.state) + assessorSuffix(expectation);
     const from = expectation.source === 'space' ? '  [space default]' : '';
     /*
      * `sentence` before `text`.
@@ -75,7 +98,7 @@ function line(expectation) {
      * thing is owed. The fallback is for a row that predates the resolved field.
      */
     const sentence = expectation.sentence || expectation.text;
-    return `  ${expectation.id.padEnd(18)} ${label.padEnd(18)} ${sentence}${evidenceGap(expectation)}${from}`;
+    return `  ${expectation.id.padEnd(18)} ${label.padEnd(22)} ${sentence}${evidenceGap(expectation)}${from}`;
 }
 class TasksExpectations extends base_command_1.BaseCommand {
     static description = 'Show what must be true before the Task can close and the evidence-backed assessment state';
@@ -127,9 +150,13 @@ class TasksExpectations extends base_command_1.BaseCommand {
         // "2 of 2 met" for a Task where one expectation was dropped, which is the
         // one thing a reader checking this line needs to know.
         const waived = gating.filter((e) => e.state === 'waived').length;
-        const met = gating.filter((e) => e.met).length - waived;
+        const met = gating.filter((e) => e.passed ?? e.state === 'met').length;
+        const rejected = gating.filter((e) => e.state === 'unmet').length;
         this.log('');
-        this.log(`${met} of ${gating.length} met${waived > 0 ? ` · ${waived} waived` : ''}  ·  overall: ${acceptance.state}`);
+        this.log(`${met} of ${gating.length} met` +
+            (waived > 0 ? ` · ${waived} waived` : '') +
+            (rejected > 0 ? ` · ${rejected} unmet` : '') +
+            `  ·  overall: ${acceptance.state}`);
         // Space defaults are copied into the Task at creation. `source=space`
         // remains useful provenance, but these are Task-owned Expectations now and
         // are assessed exactly like explicitly declared ones.
@@ -156,6 +183,24 @@ class TasksExpectations extends base_command_1.BaseCommand {
         if (settleable > 0) {
             this.log(`${settleable} awaiting assessment — use \`${this.config.bin} tasks expectations assess\`.`);
         }
+        /*
+         * A rejection is not an absence, and it used to read as one.
+         *
+         * `unmet` collapsed into `owed`/`unassessed`, so a reviewer's written "no"
+         * displayed as "needs assessment" — inviting someone to do the judging that
+         * had already been done, while the bulk settle skipped the row because it
+         * could see the assessment the display had hidden.
+         */
+        const rejectedRows = acceptance.expectations.filter((e) => e.state === 'unmet');
+        if (rejectedRows.length > 0) {
+            this.log(`${rejectedRows.length} judged unmet — fix the work and re-assess, or waive ` +
+                `${rejectedRows.length === 1 ? 'it' : 'them'}:`);
+            for (const row of rejectedRows) {
+                const who = row.assessedByKind ? ` by ${(0, task_closure_1.describeAssessor)(row.assessedByKind)}` : '';
+                const when = row.assessedAt ? ` on ${String(row.assessedAt).slice(0, 10)}` : '';
+                this.log(`  ${row.id}${who}${when}${row.reason ? `: ${row.reason}` : ''}`);
+            }
+        }
         // Named separately from `unjudged`, and with a different command, because
         // the two look alike on the board and are not: one needs a verdict on prose,
         // the other needs somebody to look at a thing that already exists.
@@ -200,7 +245,40 @@ class TasksExpectations extends base_command_1.BaseCommand {
         const settled = gating.filter((e) => e.met).length;
         if (gating.length > settled) {
             this.log('');
-            this.log('The current Result cannot be accepted while these Expectations remain unmet.');
+            /*
+             * Say what is OWED, not what is forbidden.
+             *
+             * This read: "The current Result cannot be accepted while these
+             * Expectations remain unmet." That gate stopped existing in `56a6ded703`
+             * — unmet Expectations are advisory, and `assertTaskMayClose` throws on
+             * exactly one code, which is not this one. The Task closes; the unmet
+             * items are stamped onto `resolution.closure`.
+             *
+             * So the sentence asserted an outcome this command never evaluated, and
+             * asserted it wrongly: an operator who believed it would go hunting for a
+             * way to force a close that needs no forcing. It is the same failure as
+             * the hard-coded "it is ready for review" that this batch removed,
+             * pointing the other way.
+             */
+            this.log(
+            // Tense-neutral on purpose: this command reads acceptance only, and
+            // fetching the Task as well — one extra round trip on every call — just
+            // to choose between "closing is allowed" and "was closed over these" is
+            // not worth it. This sentence is true before the close and after it.
+            `${gating.length - settled} Expectation(s) still owed. They do not block closing; ` +
+                'whatever is outstanding when a Task closes is recorded on `resolution.closure`.');
+        }
+        /*
+         * A legend, because two of these states are near-synonyms in English and
+         * genuinely different in what they ask of the reader.
+         */
+        const shown = new Set(acceptance.expectations.map((e) => e.state));
+        const legend = ['owed', 'unassessed', 'unmet']
+            .filter((state) => shown.has(state))
+            .map((state) => `${data_provider_3.EXPECTATION_STATE_LABEL[state]} = ${data_provider_3.EXPECTATION_STATE_HINT[state]}`);
+        if (legend.length > 1) {
+            this.log('');
+            this.log(legend.join('  ·  '));
         }
     }
 }

package/dist/commands/tasks/follow-up.js

@@ -73,8 +73,8 @@ class TasksFollowUp extends base_command_1.BaseCommand {
             description: 'Optional SLA fallback delay in seconds for event or poll_until follow-ups',
         }),
         visibility: core_1.Flags.string({
-            description: 'Whether follow-up runs silently or sends a visible message',
-            options: ['silent', 'notify'],
+            description: 'Always silent — the wake speaks only when the check finds something. Kept for compatibility; notify is not available',
+            options: ['silent'],
         }),
         priority: core_1.Flags.string({
             description: 'Follow-up task priority',

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

@@ -3,6 +3,7 @@ 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 label_ref_1 = require("../../../lib/label-ref");
 /**
  * Incremental label attach. `dataService.updateTask` only accepts a whole-list
  * `labelIds: string[]`, so we fetch the current task, append the new label
@@ -27,7 +28,7 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output the updated task as JSON' }),
         'label-id': core_1.Flags.string({
-            description: 'Label id to attach (repeatable). Create labels with `skrr tasks labels create`.',
+            description: 'Label to attach — id, or a name from `skrr labels list --applicable-to task`. An unknown name is refused, never created (repeatable).',
             multiple: true,
             required: true,
         }),
@@ -35,10 +36,26 @@ class TasksLabelsAttach extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksLabelsAttach);
-        const incoming = (flags['label-id'] ?? []).map((id) => id.trim()).filter((id) => id.length > 0);
-        if (incoming.length === 0) {
+        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 });
         }
+        // A name is resolved against the DECLARED vocabulary; an unknown one is
+        // refused with the near misses named, never created. See lib/label-ref.
+        let incoming = [];
+        try {
+            incoming = await (0, label_ref_1.resolveLabelRefs)(refs, {
+                applicableTo: 'task',
+                ...(process.env.OVERSKY_WORKSPACE_ID
+                    ? { workspaceId: process.env.OVERSKY_WORKSPACE_ID }
+                    : {}),
+            });
+        }
+        catch (err) {
+            if (err instanceof label_ref_1.LabelRefError)
+                this.error(err.message, { exit: 1 });
+            this.handleApiError(err);
+        }
         let current;
         try {
             current = await data_provider_1.dataService.getTask(args.id, { enrich: false });

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

@@ -3,6 +3,7 @@ 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 label_ref_1 = require("../../../lib/label-ref");
 /**
  * Incremental label detach. Mirror of `labels attach` — fetch, filter, write
  * back the whole `labelIds` list. Matches label ids exactly (they are opaque
@@ -20,7 +21,7 @@ class TasksLabelsDetach extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output the updated task as JSON' }),
         'label-id': core_1.Flags.string({
-            description: 'Label id to detach (repeatable)',
+            description: 'Label to detach — id, or a name from `skrr labels list --applicable-to task` (repeatable)',
             multiple: true,
             required: true,
         }),
@@ -28,10 +29,27 @@ class TasksLabelsDetach extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksLabelsDetach);
-        const targets = new Set((flags['label-id'] ?? []).map((id) => id.trim()).filter((id) => id.length > 0));
-        if (targets.size === 0) {
+        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 });
         }
+        // A name is resolved against the DECLARED vocabulary; an unknown one is
+        // refused with the near misses named, never created. See lib/label-ref.
+        let resolvedTargets = [];
+        try {
+            resolvedTargets = await (0, label_ref_1.resolveLabelRefs)(refs, {
+                applicableTo: 'task',
+                ...(process.env.OVERSKY_WORKSPACE_ID
+                    ? { workspaceId: process.env.OVERSKY_WORKSPACE_ID }
+                    : {}),
+            });
+        }
+        catch (err) {
+            if (err instanceof label_ref_1.LabelRefError)
+                this.error(err.message, { exit: 1 });
+            this.handleApiError(err);
+        }
+        const targets = new Set(resolvedTargets);
         let current;
         try {
             current = await data_provider_1.dataService.getTask(args.id, { enrich: false });

package/dist/commands/tasks/lifecycle/attach.d.ts

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

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

@@ -0,0 +1,47 @@
+"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 task_lifecycle_output_1 = require("../../../lib/task-lifecycle-output");
+class TasksLifecycleAttach extends base_command_1.BaseCommand {
+    static description = 'Attach a lifecycle protocol to a Task — a built-in pack or a Space definition';
+    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    static flags = {
+        pack: core_1.Flags.string({ description: "Built-in pack id, e.g. 'finding' or 'doc_to_task'" }),
+        definition: core_1.Flags.string({ description: 'WorkflowDefinition id (kind task_lifecycle)' }),
+        version: core_1.Flags.string({ description: 'Pin a specific published version id' }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleAttach);
+        const taskId = await this.resolveTaskReference(args.id);
+        if (flags.pack && flags.definition) {
+            this.error('Pass either --pack or --definition, not both.', { exit: 2 });
+        }
+        if (!flags.pack && !flags.definition) {
+            this.error('Pass --pack <id> or --definition <id>. See: tasks lifecycle definitions', {
+                exit: 2,
+            });
+        }
+        let response;
+        try {
+            response = await data_provider_1.dataService.attachTaskLifecycle({
+                taskId,
+                ...(flags.pack ? { packId: flags.pack } : {}),
+                ...(flags.definition ? { definitionId: flags.definition } : {}),
+                ...(flags.version ? { versionId: flags.version } : {}),
+            });
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        this.log(`Attached lifecycle${flags.pack ? ` pack '${flags.pack}'` : ` definition ${flags.definition}`}.`);
+        (0, task_lifecycle_output_1.renderTaskLifecycleSummary)(response, (line) => this.log(line));
+        this.log(`Start it: skrr tasks lifecycle start ${taskId}`);
+    }
+}
+exports.default = TasksLifecycleAttach;

package/dist/commands/tasks/lifecycle/definitions.d.ts

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

package/dist/commands/tasks/lifecycle/definitions.js

@@ -0,0 +1,59 @@
+"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 TasksLifecycleDefinitions extends base_command_1.BaseCommand {
+    static description = 'List the lifecycle definitions and built-in packs a Task can attach';
+    static args = {
+        id: core_1.Args.string({
+            required: true,
+            ignoreStdin: true,
+            description: 'Task ID or identifier — definitions are listed for its Space',
+        }),
+    };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksLifecycleDefinitions);
+        const taskId = await this.resolveTaskReference(args.id);
+        let response;
+        try {
+            response = await data_provider_1.dataService.listTaskLifecycleDefinitions(taskId);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        if (response.packs.length) {
+            this.log('Built-in packs:');
+            for (const pack of response.packs) {
+                this.log(`  ${pack.id} v${pack.packVersion} — ${pack.title}${pack.description ? ` — ${pack.description}` : ''}`);
+                if (pack.stageKeys?.length) {
+                    this.log(`      stages: ${pack.stageKeys.join(' → ')}`);
+                }
+            }
+        }
+        if (response.definitions.length) {
+            this.log('Space definitions:');
+            for (const definition of response.definitions) {
+                this.log(`  ${definition.id} v${definition.version} — ${definition.title}${definition.packId ? ` (pack ${definition.packId} v${definition.packVersion ?? '?'})` : ''}`);
+                // `attach --version` and `migrate --version` take a VERSION id, and
+                // this was the only place they could come from — and it printed the
+                // definition id and a version NUMBER, neither of which those flags
+                // accept. `migrate` was unusable without reading the API.
+                if (definition.publishedVersionId) {
+                    this.log(`      published version: ${definition.publishedVersionId}  (pass to --version)`);
+                }
+                if (definition.stageKeys?.length) {
+                    this.log(`      stages: ${definition.stageKeys.join(' → ')}`);
+                }
+            }
+        }
+        if (!response.packs.length && !response.definitions.length) {
+            this.log('No lifecycle definitions are available to this Task.');
+        }
+    }
+}
+exports.default = TasksLifecycleDefinitions;

package/dist/commands/tasks/lifecycle/detach.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../../base-command';
+export default class TasksLifecycleDetach extends BaseCommand {
+    static description: string;
+    /**
+     * oclif prints `description` in help and nothing else, so a one-liner that
+     * repeats the summary tells a reader nothing about an operation that is not
+     * obviously reversible. Say what it does to each thing it touches.
+     */
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        reason: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}