@skrr-ai/cli 0.1.37 → 0.1.38

package/dist/commands/spaces/workflows/lifecycle-diagnostics.js

@@ -33,13 +33,73 @@ class SpacesWorkflowsLifecycleDiagnostics extends base_command_1.BaseCommand {
             `, ${response.stages.completed} completed` +
             ` (median ${Math.round(response.stages.durationMs.median / 1000)}s` +
             `, max ${Math.round(response.stages.durationMs.max / 1000)}s)`);
-        this.log(`  effects: ${response.effects.pending} pending` +
-            ` (oldest ${Math.round(response.effects.oldestPendingMs / 1000)}s)` +
-            `, ${response.effects.repairs} repaired`);
+        /*
+         * The server's effect counters NEST — `pending` is every effect still owed,
+         * `repairs` the owed ones that hit an error, `exhausted` the owed ones that
+         * stopped retrying — so they must be printed as parts of one number, never
+         * side by side. Side by side, one stopped effect read as "1 pending (oldest
+         * 8h), 1 repaired, 1 stopped retrying": three effects, one of them
+         * apparently fixed, when there was exactly one and nothing was fixed.
+         */
+        const { pending: owed, exhausted: stopped = 0, repairs: faulted } = response.effects;
+        const retrying = Math.max(0, owed - stopped);
+        this.log(owed
+            ? `  effects: ${owed} owed (oldest ${Math.round(response.effects.oldestPendingMs / 1000)}s)` +
+                ` — ${retrying} still retrying, ${stopped} stopped; ${faulted} hit an error`
+            : '  effects: none owed');
         this.log(`  transitions: ${response.transitions.applied} applied` +
             `, ${response.transitions.gated} gated` +
             `, ${response.transitions.superseded} superseded`);
         this.log(`  orphan stages: ${response.orphans}`);
+        /*
+         * WHAT TO DO. The counts above tell an operator how much; LC-13's bar is
+         * that each shape of "stuck" also names its repair, because "slow", "stuck"
+         * and "waiting for me" are three different facts and one undifferentiated
+         * number is not actionable. Only shapes that are actually present print,
+         * so a healthy Space says so instead of listing remedies for nothing.
+         */
+        // Diagnostics are aggregate by design, so every repair that needs a Task
+        // must say how to FIND that Task — and in the Space the operator just
+        // named, so the command runs as printed rather than as a template.
+        const space = response.spaceId;
+        // Every owed effect places the lifecycle's exceptional hold, so this one
+        // query finds the Tasks behind both retrying and stopped effects. Holds
+        // other authors placed show up too; the NEXT column says which is which.
+        const findHeld = `skrr tasks list --space ${space} --actionability-reason exceptional_hold`;
+        const actions = [];
+        const waitingOn = response.stages.waitingOn;
+        if (waitingOn?.human) {
+            actions.push(`${waitingOn.human} stage(s) waiting on a person — nothing is broken; a person owes a decision. ` +
+                `Find them: skrr tasks list --space ${space} --actionable-by human`);
+        }
+        if (waitingOn?.agent) {
+            actions.push(`${waitingOn.agent} stage(s) waiting on an agent — an agent owes a turn. ` +
+                `Find them: skrr tasks list --space ${space} --actionable-by agent`);
+        }
+        if (response.bindings.drifted) {
+            actions.push(`${response.bindings.drifted} binding(s) whose Task status disagrees with its stage — ` +
+                'run "skrr tasks lifecycle reconcile <task-id>", or move the Task back to the stage\'s status');
+        }
+        if (stopped) {
+            actions.push(`${stopped} effect(s) stopped retrying — they will not run again on their own. Find them: ${findHeld}; ` +
+                '"skrr tasks lifecycle show <task-id>" names the error; fix the cause, then "skrr tasks lifecycle reconcile <task-id>"');
+        }
+        if (retrying) {
+            actions.push(`${retrying} effect(s) still retrying — usually transient. If they persist, find them: ${findHeld}; ` +
+                '"skrr tasks lifecycle show <task-id>" names the error');
+        }
+        if (response.orphans) {
+            actions.push(`${response.orphans} orphan stage(s) — a run waiting for a Task that moved on; ` +
+                '"skrr tasks lifecycle reconcile <task-id>" re-syncs it');
+        }
+        this.log('');
+        if (!actions.length) {
+            this.log('Nothing needs attention.');
+            return;
+        }
+        this.log('What to do:');
+        for (const action of actions)
+            this.log(`  - ${action}`);
     }
 }
 exports.default = SpacesWorkflowsLifecycleDiagnostics;

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

@@ -4,10 +4,35 @@ const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const bulk_task_targets_1 = require("../../../lib/bulk-task-targets");
+/**
+ * Parse `<agentId>:<actionId>`, splitting on the FIRST colon only.
+ *
+ * Agent ids never contain a colon; action ids can. This used to split on every
+ * colon and keep segments 0 and 1, so `<agent>:<action>:ANYTHING` silently
+ * attached `<agent>:<action>` — the caller asked for one thing and got another,
+ * exit 0 (OSK-9636). Keeping the remainder as the action id means an extra
+ * segment reaches the server as part of an id that does not exist, and is
+ * refused there.
+ *
+ * A space custom action's projected id is `space-custom:<id>`. Read as a ref it
+ * became agent `space-custom`, and the server correctly answered "Agent
+ * space-custom not found" — true of a string nobody meant as an agent id, and
+ * no help (OSK-9637). Those actions run from the space and are deliberately not
+ * attachable, so say that instead.
+ */
 function parseRef(input) {
-    const [agentId, actionId] = input.split(':').map((s) => s.trim());
-    if (!agentId || !actionId)
-        return null;
+    const trimmed = input.trim();
+    const spaceCustom = `"${trimmed}" is a space custom action. Those run from the space and cannot be attached to a task — only agent quick actions can. List attachable ones with: skrr spaces actions available <space-id>`;
+    if ((0, data_provider_1.isSpaceCustomActionId)(trimmed))
+        return { problem: spaceCustom };
+    const colon = trimmed.indexOf(':');
+    const agentId = colon > 0 ? trimmed.slice(0, colon).trim() : '';
+    const actionId = colon > 0 ? trimmed.slice(colon + 1).trim() : '';
+    if (!agentId || !actionId) {
+        return { problem: `Invalid ref "${input}" — expected <agentId>:<actionId>.` };
+    }
+    if ((0, data_provider_1.isSpaceCustomActionId)(actionId))
+        return { problem: spaceCustom };
     return { agentId, actionId };
 }
 const refKey = (ref) => `${ref.agentId}:${ref.actionId}`;
@@ -55,11 +80,11 @@ class TasksActionsAttach extends base_command_1.BaseCommand {
         }
         const incoming = [];
         for (const raw of refPositionals) {
-            const ref = parseRef(raw);
-            if (!ref) {
-                this.error(`Invalid ref "${raw}" — expected <agentId>:<actionId>.`, { exit: 1 });
+            const parsed = parseRef(raw);
+            if ('problem' in parsed) {
+                this.error(parsed.problem, { exit: 1 });
             }
-            incoming.push(ref);
+            incoming.push(parsed);
         }
         if (incoming.length === 0) {
             this.error('At least one <agentId>:<actionId> ref is required. Discover refs with: skrr spaces actions available <space-id>', { exit: 1 });

package/dist/commands/tasks/complete.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.describePendingReview = describePendingReview;
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
+const task_closure_1 = require("../../lib/task-closure");
 const api_fetch_1 = require("../../lib/api-fetch");
 const outbox_1 = require("../../lib/outbox");
 const prompt_1 = require("../../lib/prompt");
@@ -271,6 +272,18 @@ class TasksComplete extends base_command_1.BaseCommand {
         });
         if (pending)
             this.log(pending);
+        /*
+         * Say what was closed over, on the door that actually closes things.
+         *
+         * `tasks complete` reported nothing about the closure at all — no blockers,
+         * no `overrode` — so the person who forced past an owner-declared required
+         * Review was never told they had. Only `tasks move` read the field, and this
+         * is the more common way to finish a Task. Same renderer as `move` and
+         * `show`, so all three describe one close identically.
+         */
+        for (const sentence of (0, task_closure_1.closureSnapshotLines)(result.task?.resolution?.closure)) {
+            this.log(sentence);
+        }
         for (const advisory of result.advisories || [])
             this.warn(advisory.message);
         if (url)

package/dist/commands/tasks/create.js

@@ -240,7 +240,7 @@ class TasksCreate extends base_command_1.BaseCommand {
                 'Omit to pin the definition’s current published version at create time.',
         }),
         'lifecycle-pack': core_1.Flags.string({
-            description: 'Bind the created task to a built-in lifecycle pack (e.g. finding, doc-to-task). ' +
+            description: 'Bind the created task to a built-in lifecycle pack (finding, doc_to_task). ' +
                 'Alternative to --lifecycle-definition.',
         }),
     };

package/dist/commands/tasks/events/append.js

@@ -16,10 +16,20 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
     // the retired vocabulary read as the intended path — which is how it kept
     // getting exercised.
     static summary = 'DEPRECATED compatibility spelling for `tasks updates add` — append a legacy task event';
+    // The FULL mapping, not a sample of it. The previous description named
+    // `handoff`/`checkpoint` and `started|lifecycle` and stopped — so a caller
+    // passing `--kind evidence` had no way to learn, before writing, that it
+    // becomes a `verification` Update. Those are different claims: `evidence`
+    // says a flow was exercised, `verification` says a claim was CHECKED, and the
+    // typed-Update vocabulary exists precisely so the two cannot be confused.
+    // Mirrors `LEGACY_KIND_TO_UPDATE_TYPE` in `api/server/services/TaskWorkEvent.js`.
     static description = 'DEPRECATED compatibility adapter for the historical Event vocabulary. Every kind is ' +
-        'stored as a canonical Update, so `--kind handoff` and `--kind checkpoint` both become ' +
-        '`progress`, and `--kind started|lifecycle` writes only to the Activity ledger and will ' +
-        'NOT appear in `tasks updates list`. Use `tasks updates add` instead.';
+        'stored as a canonical Update of a DIFFERENT name, so read this before relying on one: ' +
+        '`evidence` and `verification` both become `verification`; `checkpoint`, `changed`, ' +
+        '`completed` and `handoff` all become `progress`; `input_requested` and `failed` become ' +
+        '`blocker`; `decision` stays `decision`. `--kind started|lifecycle` writes only to the ' +
+        'Activity ledger and will NOT appear in `tasks updates list`. Use `tasks updates add` ' +
+        'instead, which writes the type you name.';
     static examples = [
         '<%= config.bin %> tasks events append <task-id> --kind checkpoint --idempotency-key "<task-id>:first-pass" --summary "Parser handles nested fences"',
         '<%= config.bin %> tasks events append <task-id> --kind decision --idempotency-key "<task-id>:storage-choice" --summary "Chose the CRDT path" --evidence "A direct contentHtml write is reverted by the next render tick"',
@@ -53,7 +63,7 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
         // `Invalid request data` / HTTP_400. (OSK-4888)
         kind: core_1.Flags.string({
             required: true,
-            description: 'Event kind at a meaningful work boundary',
+            description: 'Legacy event kind. Stored as a canonical Update of a different name — see the mapping in the description above, and prefer `tasks updates add`',
             options: [...tasks_1.TASK_WORK_EVENT_KINDS],
         }),
         summary: core_1.Flags.string({ required: true, description: 'What is newly true, in one sentence' }),
@@ -108,8 +118,21 @@ class TasksEventsAppend extends base_command_1.BaseCommand {
         if (written.canonicalType) {
             this.log(`Recorded on ${task.id} as a ${written.canonicalType} Update` +
                 `${written.id ? ` (${written.id})` : ''}.`);
-            this.log(`\`tasks events append\` is a compatibility spelling; \`${this.config.bin} tasks updates add\` ` +
-                `is the canonical command, and \`${this.config.bin} tasks updates list\` reads them back.`);
+            /*
+             * Scope the claim to this KIND.
+             *
+             * "a compatibility spelling" reads as "same command, older name" — so a
+             * caller who has just used it successfully reaches for it again with a
+             * kind it does not take. The two vocabularies overlap in only three of
+             * fourteen values (`decision`, `blocker`, `verification`), and this line
+             * is printed on exactly those — confirming the general claim precisely
+             * where it happens to be true. `finding` and `progress` exist only on the
+             * canonical command; `evidence`, `checkpoint` and the rest only here.
+             */
+            this.log(`\`tasks events append --kind ${written.canonicalType}\` maps onto ` +
+                `\`${this.config.bin} tasks updates add --type ${written.canonicalType}\`, which is the ` +
+                'canonical command. Their vocabularies differ otherwise — `--type ' +
+                'progress|finding` exist only there — and `tasks updates list` reads them back.');
             return;
         }
         // `--kind started|lifecycle` produces no Update at all: it writes a

package/dist/commands/tasks/expectations/assess.d.ts

@@ -16,6 +16,7 @@ export default class TasksExpectationsAssess extends BaseCommand {
         'spec-version': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'idempotency-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         all: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-unmet': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     /**

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

@@ -43,7 +43,12 @@ class TasksExpectationsAssess extends base_command_1.BaseCommand {
         '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 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' }),
     };
@@ -56,11 +61,26 @@ class TasksExpectationsAssess extends base_command_1.BaseCommand {
      * batch verb must never do. Overriding an existing assessment stays a
      * deliberate, single, named act.
      */
-    async awaitingIds(taskId) {
+    async awaitingIds(taskId, { includeUnmet = false } = {}) {
         const acceptance = await data_provider_1.dataService.getTaskAcceptance(taskId);
-        return acceptance.expectations
-            .filter((expectation) => expectation.gating && !expectation.met && !expectation.assessmentId)
+        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();
@@ -123,17 +143,35 @@ class TasksExpectationsAssess extends base_command_1.BaseCommand {
         };
         if (flags.all) {
             let ids;
+            let rejected;
             try {
-                ids = await this.awaitingIds(task.id);
+                ({ 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

package/dist/commands/tasks/expectations.js

@@ -4,6 +4,7 @@ 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.
@@ -13,18 +14,21 @@ const task_closure_1 = require("../../lib/task-closure");
  * 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.
  *
@@ -75,7 +79,9 @@ function evidenceGap(expectation) {
 function assessorSuffix(expectation) {
     if (!expectation.assessedByKind)
         return '';
-    if (!['met', 'waived'].includes(expectation.state))
+    // `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)})`;
 }
@@ -144,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.
@@ -173,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.
@@ -217,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/lifecycle/definitions.js

@@ -5,7 +5,13 @@ 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 }) };
+    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();
@@ -24,12 +30,25 @@ class TasksLifecycleDefinitions extends base_command_1.BaseCommand {
             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})` : ''}`);
+                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) {

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

@@ -1,11 +1,18 @@
 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>;

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

@@ -5,15 +5,49 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 class TasksLifecycleDetach extends base_command_1.BaseCommand {
     static description = 'Detach the lifecycle from a Task — fences the generation, leaves the run as history';
-    static args = { id: core_1.Args.string({ required: true, ignoreStdin: true }) };
+    /**
+     * 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 = [
+        '<%= config.bin %> tasks lifecycle detach OSK-1234 --dry-run',
+        '<%= config.bin %> tasks lifecycle detach OSK-1234 --reason "Wrong protocol for this work"',
+    ];
+    static args = {
+        id: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Task ID or identifier' }),
+    };
     static flags = {
-        reason: core_1.Flags.string({ description: 'Why the lifecycle is detaching' }),
+        reason: core_1.Flags.string({ description: 'Why the lifecycle is detaching; recorded in history' }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Describe what detaching would do and exit without writing',
+        }),
         json: core_1.Flags.boolean({ description: 'Output JSON' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksLifecycleDetach);
         const taskId = await this.resolveTaskReference(args.id);
+        if (flags['dry-run']) {
+            let current;
+            try {
+                current = await data_provider_1.dataService.getTaskLifecycle(taskId);
+            }
+            catch (error) {
+                this.handleApiError(error);
+            }
+            if (flags.json)
+                return this.log(JSON.stringify({ dryRun: true, ...current }, null, 2));
+            const lifecycle = current.lifecycle;
+            if (!lifecycle)
+                return this.log('No lifecycle is attached to this Task — nothing to detach.');
+            this.log(`Would detach ${lifecycle.packId ? `pack ${lifecycle.packId}` : `definition ${lifecycle.definitionId}`}` +
+                ` at generation ${lifecycle.generation}, stage ${lifecycle.currentStageKey ?? '—'}.`);
+            this.log('  The run is cancelled and kept as history; nothing already recorded is removed.');
+            this.log('  The generation is bumped, so no in-flight writer from the old run can land.');
+            this.log('  Re-attaching afterwards starts a NEW generation — it does not resume this one.');
+            return;
+        }
         let response;
         try {
             response = await data_provider_1.dataService.detachTaskLifecycle({
@@ -26,7 +60,13 @@ class TasksLifecycleDetach extends base_command_1.BaseCommand {
         }
         if (flags.json)
             return this.log(JSON.stringify(response, null, 2));
-        this.log('Detached lifecycle from the Task.');
+        const lifecycle = response.lifecycle;
+        // Name what changed. "Detached lifecycle from the Task." left the reader to
+        // diff the state afterwards to learn what had happened.
+        this.log(`Detached${lifecycle?.packId ? ` pack ${lifecycle.packId}` : ''} — the run is cancelled and` +
+            ` kept as history, and the binding is now generation ${lifecycle?.generation ?? '?'}` +
+            ` (${lifecycle?.status ?? 'detached'}).`);
+        this.log('Re-attach with: skrr tasks lifecycle attach <task-id> --pack <pack>');
     }
 }
 exports.default = TasksLifecycleDetach;

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

@@ -1,11 +1,13 @@
 import { BaseCommand } from '../../../base-command';
 export default class TasksLifecycleMigrate extends BaseCommand {
     static description: string;
+    static examples: string[];
     static args: {
         id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
         version: import("@oclif/core/lib/interfaces").OptionFlag<string, 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>;