@skrr-ai/cli 0.1.37 → 0.1.39

package/dist/commands/spaces/actions/update.js

@@ -5,6 +5,7 @@ const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
 const prompt_1 = require("../../../lib/prompt");
 const space_output_1 = require("../../../lib/space-output");
+const space_custom_actions_1 = require("../../../lib/space-custom-actions");
 class SpacesActionsUpdate extends base_command_1.BaseCommand {
     static description = 'Update a custom action in a space';
     static args = {
@@ -14,10 +15,10 @@ class SpacesActionsUpdate extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output as JSON' }),
         'from-json': core_1.Flags.string({ description: 'JSON action patch' }),
-        label: core_1.Flags.string({ description: 'Button label' }),
+        label: space_custom_actions_1.spaceCustomActionLabelFlag,
         prompt: core_1.Flags.string({ description: 'Prompt sent when the action runs' }),
         color: core_1.Flags.string({ description: 'Color hex' }),
-        icon: core_1.Flags.string({ description: 'Lucide icon name' }),
+        icon: space_custom_actions_1.spaceCustomActionIconFlag,
         skill: core_1.Flags.string({ description: 'Optional skill ID' }),
     };
     async run() {
@@ -30,21 +31,39 @@ class SpacesActionsUpdate extends base_command_1.BaseCommand {
         catch (err) {
             this.error(err.message, { exit: 1 });
         }
-        const payload = (0, prompt_1.mergeDefined)(body, {
+        const patch = (0, prompt_1.mergeDefined)(body, {
             label: flags.label,
             prompt: flags.prompt,
             color: flags.color,
             icon: flags.icon,
             skillId: flags.skill,
         });
-        if (!Object.keys(payload).length)
+        if (!Object.keys(patch).length)
             this.error('Nothing to update.', { exit: 1 });
+        const iconProblem = (0, space_custom_actions_1.spaceCustomActionIconProblem)(patch.icon);
+        if (iconProblem)
+            this.error(iconProblem, { exit: 1 });
         let result;
+        let leadAgentId;
         try {
+            // The server replaces the WHOLE element (`$set: {'customActions.$': action}`)
+            // and validates a complete action — `id`, `label`, `prompt`, `color` — whose
+            // `id` must equal the path's. This command sent only the changed flags, so
+            // every call failed that validation: `--label` alone, `--prompt` alone, all
+            // of them together, 400 "Invalid request data" every time (OSK-9646). The
+            // web editor never hit it because it always sends the full action.
+            //
+            // So the patch is applied over the stored action here and sent whole.
+            const space = await data_provider_1.dataService.getSpace(args.space);
+            leadAgentId = space.leadAgentId;
+            const current = (space.customActions ?? []).find((action) => action.id === args.id);
+            if (!current) {
+                this.error(`No custom action ${args.id} in space ${args.space}. List them with \`spaces actions list ${args.space}\`.`, { exit: 1 });
+            }
             result = await data_provider_1.dataService.updateSpaceCustomAction({
                 spaceId: args.space,
                 actionId: args.id,
-                action: payload,
+                action: { ...current, ...patch, id: args.id },
             });
         }
         catch (err) {
@@ -54,6 +73,9 @@ class SpacesActionsUpdate extends base_command_1.BaseCommand {
             this.log(JSON.stringify((0, space_output_1.withSpaceResourceUrls)(this.cliConfig.baseURL, args.space, 'actions', result, ['id']), null, 2));
         else
             this.log(`Updated custom action ${args.id}.`);
+        const unrunnable = (0, space_custom_actions_1.spaceActionsNotRunnableReason)({ id: args.space, leadAgentId }, this.config.bin);
+        if (unrunnable)
+            this.warn(unrunnable);
     }
 }
 exports.default = SpacesActionsUpdate;

package/dist/commands/spaces/label-summaries.d.ts

@@ -0,0 +1,27 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr spaces label-summaries` — the label DEFINITIONS carried by every Space
+ * you can view, in one request.
+ *
+ * The third of the sidebar's batch reads, beside `spaces member-summaries` and
+ * `spaces task-rollups`, and the one that was never bound. `Space.labelIds`
+ * already says which Space carries which label, so what a caller holding a list
+ * of Spaces is missing is only the name and colour to resolve those ids
+ * against — and `GET /api/labels` takes exactly ONE (scope, scopeId) pair, so
+ * resolving them otherwise costs a request per row.
+ *
+ * Deliberately a flat list, matching the endpoint: one map, not one map per row.
+ *
+ * A label whose row is not returned is one the caller genuinely cannot read —
+ * another user's private label attached to a shared Space. It is reported as
+ * unresolved rather than hidden, because "this Space has a label you cannot
+ * see" and "this Space has no labels" are different facts.
+ */
+export default class SpacesLabelSummaries extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/spaces/label-summaries.js

@@ -0,0 +1,64 @@
+"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");
+/**
+ * `skrr spaces label-summaries` — the label DEFINITIONS carried by every Space
+ * you can view, in one request.
+ *
+ * The third of the sidebar's batch reads, beside `spaces member-summaries` and
+ * `spaces task-rollups`, and the one that was never bound. `Space.labelIds`
+ * already says which Space carries which label, so what a caller holding a list
+ * of Spaces is missing is only the name and colour to resolve those ids
+ * against — and `GET /api/labels` takes exactly ONE (scope, scopeId) pair, so
+ * resolving them otherwise costs a request per row.
+ *
+ * Deliberately a flat list, matching the endpoint: one map, not one map per row.
+ *
+ * A label whose row is not returned is one the caller genuinely cannot read —
+ * another user's private label attached to a shared Space. It is reported as
+ * unresolved rather than hidden, because "this Space has a label you cannot
+ * see" and "this Space has no labels" are different facts.
+ */
+class SpacesLabelSummaries extends base_command_1.BaseCommand {
+    static description = 'Show the label definitions used across every space you can view';
+    static examples = [
+        '<%= config.bin %> spaces label-summaries',
+        '<%= config.bin %> spaces label-summaries --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(SpacesLabelSummaries);
+        let response;
+        try {
+            response = await data_provider_1.dataService.listSpaceLabelSummaries();
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const labels = response.labels || [];
+        if (labels.length === 0) {
+            this.log('No labels on any space you can view.');
+            return;
+        }
+        const clip = (text, width) => text.length > width ? `${text.slice(0, width - 3)}...` : text;
+        this.log(`${'LABEL'.padEnd(28)} ${'SCOPE'.padEnd(10)} ${'COLOR'.padEnd(9)} ${'APPLIES TO'.padEnd(24)} ID`);
+        for (const label of labels) {
+            // `applicableTo` is what the label may be attached to, which is not the
+            // same as its scope — a workspace-scoped label can still be task-only.
+            const appliesTo = (label.applicableTo || []).join(', ') || '-';
+            this.log(`${clip(label.name, 28).padEnd(28)} ${String(label.scope ?? '-').padEnd(10)} ` +
+                `${String(label.color ?? '-').padEnd(9)} ${clip(appliesTo, 24).padEnd(24)} ${label.id}`);
+        }
+    }
+}
+exports.default = SpacesLabelSummaries;

package/dist/commands/spaces/task-rollups.d.ts

@@ -3,6 +3,11 @@ import { BaseCommand } from '../../base-command';
  * `skrr spaces task-rollups` — task-status counts for every Space you can view,
  * in one request: the same rollup the Spaces sidebar row reads, counted by the
  * project-rollup rules (`done` is done only; `open` excludes cancelled).
+ *
+ * The SIGNAL column is the derived work band (`spaces/derive.ts`) — what the
+ * board is actually doing, as opposed to the status somebody declared on it.
+ * Sorting puts the boards that want a person first, which is the reason to run
+ * this from a terminal at all.
  */
 export default class SpacesTaskRollups extends BaseCommand {
     static description: string;

package/dist/commands/spaces/task-rollups.js

@@ -7,6 +7,11 @@ const base_command_1 = require("../../base-command");
  * `skrr spaces task-rollups` — task-status counts for every Space you can view,
  * in one request: the same rollup the Spaces sidebar row reads, counted by the
  * project-rollup rules (`done` is done only; `open` excludes cancelled).
+ *
+ * The SIGNAL column is the derived work band (`spaces/derive.ts`) — what the
+ * board is actually doing, as opposed to the status somebody declared on it.
+ * Sorting puts the boards that want a person first, which is the reason to run
+ * this from a terminal at all.
  */
 class SpacesTaskRollups extends base_command_1.BaseCommand {
     static description = 'Show task-status counts for every space you can view';
@@ -46,7 +51,11 @@ class SpacesTaskRollups extends base_command_1.BaseCommand {
             // A partial walk is not the whole picture; say so before the numbers.
             this.log(`Degraded: ${(response.warnings || []).join('; ') || 'some spaces were not counted'}`);
         }
-        const rows = [...(response.rollups || [])].sort((a, b) => b.tasks.open - a.tasks.open);
+        // Most-urgent first: a parked agent, then a blocked board, then a stalled
+        // one, then the rest by open count. The band order is the shared one, so
+        // this list and the web sidebar rank the same boards the same way.
+        const bandRank = (rollup) => data_provider_1.SPACE_ACTIVITY_BAND_ORDER.indexOf((0, data_provider_1.spaceWorkBand)(rollup));
+        const rows = [...(response.rollups || [])].sort((a, b) => bandRank(a.tasks) - bandRank(b.tasks) || b.tasks.open - a.tasks.open);
         if (rows.length === 0) {
             this.log('No spaces with tasks.');
             return;
@@ -54,11 +63,13 @@ class SpacesTaskRollups extends base_command_1.BaseCommand {
         const label = (spaceId) => {
             const title = titles.get(spaceId);
             const text = title ? `${title} (${spaceId.slice(0, 8)})` : spaceId;
-            return text.length > 48 ? `${text.slice(0, 45)}...` : text;
+            return text.length > 44 ? `${text.slice(0, 41)}...` : text;
         };
-        this.log(`${'SPACE'.padEnd(48)} ${'OPEN'.padStart(5)} ${'DONE'.padStart(5)} ${'BLOCKED'.padStart(7)} ${'TOTAL'.padStart(5)}`);
+        this.log(`${'SPACE'.padEnd(44)} ${'SIGNAL'.padEnd(15)} ${'OPEN'.padStart(5)} ${'DONE'.padStart(5)} ${'BLOCKED'.padStart(7)} ${'TOTAL'.padStart(5)}`);
         for (const { spaceId, tasks } of rows) {
-            this.log(`${label(spaceId).padEnd(48)} ${String(tasks.open).padStart(5)} ${String(tasks.done).padStart(5)} ` +
+            const band = (0, data_provider_1.spaceWorkBand)(tasks);
+            this.log(`${label(spaceId).padEnd(44)} ${(data_provider_1.SPACE_ACTIVITY_BAND_LABELS[band] ?? band).padEnd(15)} ` +
+                `${String(tasks.open).padStart(5)} ${String(tasks.done).padStart(5)} ` +
                 `${String(tasks.blocked).padStart(7)} ${String(tasks.total).padStart(5)}`);
         }
     }

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