@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/spaces/labels/remove.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");
 const web_url_1 = require("../../../lib/web-url");
 class SpacesLabelsRemove extends base_command_1.BaseCommand {
     static description = 'Detach a label from a space';
@@ -15,16 +16,35 @@ class SpacesLabelsRemove extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output the updated space as JSON' }),
-        label: core_1.Flags.string({ description: 'Label ID to detach', required: true }),
+        label: core_1.Flags.string({
+            description: 'Label — id, or a name from `skrr labels list --applicable-to space`. An unknown name is refused, never created.',
+            required: true,
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(SpacesLabelsRemove);
         // Detach is intentionally permissive server-side: you can remove a label
         // you can no longer read, so a revoked label never gets stuck on a space.
+        // 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 labelId = flags.label;
+        try {
+            [labelId] = await (0, label_ref_1.resolveLabelRefs)([flags.label], {
+                applicableTo: 'space',
+                ...(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 result;
         try {
-            result = await data_provider_1.dataService.removeLabelFromSpace({ spaceId: args.id, labelId: flags.label });
+            result = await data_provider_1.dataService.removeLabelFromSpace({ spaceId: args.id, labelId });
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/spaces/show.js

@@ -52,6 +52,8 @@ class SpacesShow extends base_command_1.BaseCommand {
             this.log(`URL:         ${url}`);
         this.log(`Status:      ${s.status ?? '-'}`);
         this.log(`Color:       ${s.color ?? '-'}`);
+        this.log(`Icon:        ${s.icon ?? '-'}`);
+        this.log(`Icon Color:  ${s.iconColor ?? '-'}`);
         this.log(`Leader:      ${s.leadAgentId ?? '-'}`);
         this.log(`Target Date: ${s.targetDate ?? '-'}`);
         this.log(`Goals:       ${Array.isArray(s.goalIds) ? s.goalIds.length : 0}`);

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/update.d.ts

@@ -12,6 +12,8 @@ export default class SpacesUpdate extends BaseCommand {
         description: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         status: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         color: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        icon: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'icon-color': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'lead-agent': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'target-date': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         goal: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
@@ -25,6 +27,9 @@ export default class SpacesUpdate extends BaseCommand {
         'integration-branch': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'auto-merge-tier': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'worktree-isolation': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'auto-start-on-backlog-exit': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'triage-external-intake': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'default-task-template': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/spaces/update.js

@@ -6,11 +6,19 @@ const tasks_1 = require("../../lib/tasks");
 const base_command_1 = require("../../base-command");
 const web_url_1 = require("../../lib/web-url");
 const prompt_1 = require("../../lib/prompt");
+/**
+ * Nullable PATCH fields take `none`/`null` as the clear sentinel — the same
+ * spelling `goals update` uses for --target-date/--project. `undefined` means
+ * the flag was not passed and mergeDefined leaves the field untouched.
+ */
+const clearable = (value) => value === undefined ? undefined : ['none', 'null'].includes(value.toLowerCase()) ? null : value;
 class SpacesUpdate extends base_command_1.BaseCommand {
     static description = 'Update an existing space (partial patch)';
     static examples = [
         '<%= config.bin %> spaces update <space-id> --title "New title"',
         '<%= config.bin %> spaces update <space-id> --status in_progress --color "#4f46e5"',
+        '<%= config.bin %> spaces update <space-id> --icon Rocket --icon-color "#2DD4BF"',
+        '<%= config.bin %> spaces update <space-id> --icon none',
         '<%= config.bin %> spaces update <space-id> --lead-agent <agent-id>',
         '<%= config.bin %> spaces update <space-id> --no-inherit-access',
         '<%= config.bin %> spaces update <space-id> --from-json patch.json',
@@ -28,8 +36,18 @@ class SpacesUpdate extends base_command_1.BaseCommand {
         description: core_1.Flags.string({ description: 'New description' }),
         status: core_1.Flags.string({ description: 'New status', options: [...data_provider_1.SPACE_STATUSES] }),
         color: core_1.Flags.string({ description: 'New color (hex)' }),
-        'lead-agent': core_1.Flags.string({ description: 'New Space Leader agent ID' }),
-        'target-date': core_1.Flags.string({ description: 'New target date (ISO string)' }),
+        icon: core_1.Flags.string({
+            description: 'New space icon — a curated icon name or an emoji. Pass "none" to restore the default folder.',
+        }),
+        'icon-color': core_1.Flags.string({
+            description: 'New color applied to the space icon (hex). Pass "none" to restore the neutral color.',
+        }),
+        'lead-agent': core_1.Flags.string({
+            description: 'New Space Leader agent ID. Pass "none" to clear the Leader.',
+        }),
+        'target-date': core_1.Flags.string({
+            description: 'New target date (ISO string). Pass "none" to clear it.',
+        }),
         goal: core_1.Flags.string({
             description: 'Link a goal to this space by ID (repeatable; additive). Routed through the ' +
                 'atomic link endpoint — re-linking an already-linked goal is a no-op.',
@@ -103,6 +121,20 @@ class SpacesUpdate extends base_command_1.BaseCommand {
                 'tree/branch. A per-task --worktree override wins. Merged into deliveryPolicy without ' +
                 'clobbering its other fields.',
         }),
+        'auto-start-on-backlog-exit': core_1.Flags.boolean({
+            allowNo: true,
+            description: 'Emit a nudge event when a task is dragged out of backlog, so the client can offer ' +
+                'a "Run now" toast. No silent execution.',
+        }),
+        'triage-external-intake': core_1.Flags.boolean({
+            allowNo: true,
+            description: 'Route externally sourced tasks (bots/channels) through the triage workflow state ' +
+                'instead of backlog. Enabling materializes the triage state server-side.',
+        }),
+        'default-task-template': core_1.Flags.string({
+            description: 'Default task template for new tasks in this space — a template id, reference, or ' +
+                'exact title (the server resolves it to the template). Pass "none" to clear.',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -119,9 +151,14 @@ class SpacesUpdate extends base_command_1.BaseCommand {
             description: flags.description,
             status: flags.status,
             color: flags.color,
-            leadAgentId: flags['lead-agent'],
-            targetDate: flags['target-date'],
+            icon: clearable(flags.icon),
+            iconColor: clearable(flags['icon-color']),
+            leadAgentId: clearable(flags['lead-agent']),
+            targetDate: clearable(flags['target-date']),
             inheritAccess: flags['inherit-access'],
+            autoStartOnBacklogExit: flags['auto-start-on-backlog-exit'],
+            triageExternalIntake: flags['triage-external-intake'],
+            defaultTaskTemplateId: clearable(flags['default-task-template']),
             estimateScale: flags['estimate-scale'],
             estimateScaleMigration: flags['estimate-migration'],
             defaultEstimate: flags['default-estimate'],

package/dist/commands/spaces/workflows/lifecycle-diagnostics.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../../base-command';
+export default class SpacesWorkflowsLifecycleDiagnostics extends BaseCommand {
+    static description: string;
+    static args: {
+        spaceId: 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/spaces/workflows/lifecycle-diagnostics.js

@@ -0,0 +1,105 @@
+"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 SpacesWorkflowsLifecycleDiagnostics extends base_command_1.BaseCommand {
+    static description = 'Bounded lifecycle operational counters for a Space — pending effect age, repairs, transition conflicts, orphan stages';
+    static args = {
+        spaceId: core_1.Args.string({ required: true, ignoreStdin: true, description: 'Owning Space ID' }),
+    };
+    static flags = { json: core_1.Flags.boolean({ description: 'Output JSON' }) };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SpacesWorkflowsLifecycleDiagnostics);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getSpaceLifecycleDiagnostics(args.spaceId);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+        if (flags.json)
+            return this.log(JSON.stringify(response, null, 2));
+        this.log(`Lifecycle diagnostics for space ${response.spaceId}:`);
+        this.log(`  bindings: ${response.bindings.bound} bound, ${response.bindings.active} active` +
+            `  (sampled ${response.sampledRuns} runs${response.truncated ? ', truncated' : ''})`);
+        const runStates = Object.entries(response.runs)
+            .map(([status, count]) => `${status}: ${count}`)
+            .join(', ');
+        this.log(`  runs: ${runStates || 'none'}`);
+        this.log(`  stages: ${response.stages.waiting} waiting` +
+            ` (oldest ${Math.round(response.stages.oldestWaitingMs / 1000)}s)` +
+            `, ${response.stages.completed} completed` +
+            ` (median ${Math.round(response.stages.durationMs.median / 1000)}s` +
+            `, max ${Math.round(response.stages.durationMs.max / 1000)}s)`);
+        /*
+         * 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.d.ts

@@ -31,6 +31,7 @@ export default class TasksComplete extends BaseCommand {
         'run-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         '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>;
+        force: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };

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");
@@ -60,7 +61,9 @@ function describePendingReview({ statusType, taskId, resultId, bin, advisories,
     }
     return ('The Result was submitted, but the Task is not done yet. It is waiting on an independent ' +
         `accepted Review — someone OTHER than the submitter runs: ${bin} tasks review ${taskId} ` +
-        `--result-id ${resultId || '<result-id>'} --decision accepted`);
+        `--result-id ${resultId || '<result-id>'} --decision accepted. ` +
+        `(The Task owner, or a non-owner with ${bin} tasks move ${taskId} --status done --force, ` +
+        'may close without one — an override is recorded on the resolution.)');
 }
 class TasksComplete extends base_command_1.BaseCommand {
     static description = 'Submit one versioned Result and advance the Task workflow';
@@ -101,6 +104,9 @@ class TasksComplete extends base_command_1.BaseCommand {
             description: 'Task specification version this Result answers',
         }),
         'idempotency-key': core_1.Flags.string({ description: 'Stable retry key for this exact closeout' }),
+        force: core_1.Flags.boolean({
+            description: "Close past an owner-declared required Review as a non-owner; the override is recorded on the task's resolution",
+        }),
         'from-json': core_1.Flags.string({
             description: 'JSON file containing the same canonical Result fields; "-" for stdin',
         }),
@@ -188,6 +194,7 @@ class TasksComplete extends base_command_1.BaseCommand {
             expectedRunId: flags['run-id'],
             expectedSpecVersion: flags['spec-version'],
             idempotencyKey: flags['idempotency-key'],
+            force: flags.force === true ? true : undefined,
         });
         let status;
         let summary;
@@ -224,6 +231,7 @@ class TasksComplete extends base_command_1.BaseCommand {
             sourceRunIds: stringArray(input.sourceRunIds),
             expectedRunId: optionalString(input.expectedRunId),
             expectedSpecVersion: typeof input.expectedSpecVersion === 'number' ? input.expectedSpecVersion : undefined,
+            ...(input.force === true ? { force: true } : {}),
         };
         const idempotencyKey = optionalString(input.idempotencyKey) ||
             (0, outbox_1.idempotencyKeyFor)('task-complete', identity.id, JSON.stringify(payload));
@@ -264,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.d.ts

@@ -66,6 +66,9 @@ export default class TasksCreate extends BaseCommand {
         tag: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         'label-id': import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         worktree: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'lifecycle-definition': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'lifecycle-version': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'lifecycle-pack': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
     private createTaskOrRecover;

package/dist/commands/tasks/create.js

@@ -6,6 +6,7 @@ exports.taskMatchesCreateIdentity = taskMatchesCreateIdentity;
 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");
 const prompt_1 = require("../../lib/prompt");
 const tasks_1 = require("../../lib/tasks");
 const task_instruction_offer_1 = require("../../lib/task-instruction-offer");
@@ -220,8 +221,8 @@ class TasksCreate extends base_command_1.BaseCommand {
         }),
         tag: core_1.Flags.string({ description: 'Tag (repeatable)', multiple: true }),
         'label-id': core_1.Flags.string({
-            description: 'Attach a task label by id (repeatable). Manage labels with `skrr tasks labels`. ' +
-                'Every id must be an attachable label or the server rejects the create.',
+            description: 'Attach a task label (repeatable) — id, or a name from `skrr labels list --applicable-to task`. ' +
+                'An unknown name is refused, never created. Manage labels with `skrr labels`.',
             multiple: true,
         }),
         worktree: core_1.Flags.boolean({
@@ -230,6 +231,18 @@ class TasksCreate extends base_command_1.BaseCommand {
                 'or force the shared daemon tree (--no-worktree). Omit to inherit the space ' +
                 'policy / global default (shared).',
         }),
+        'lifecycle-definition': core_1.Flags.string({
+            description: 'Bind the created task to a task_lifecycle Workflow definition in its space. ' +
+                'Validated before the write; attach failure rolls the task back.',
+        }),
+        'lifecycle-version': core_1.Flags.string({
+            description: 'Exact published version to bind (requires --lifecycle-definition). ' +
+                '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 (finding, doc_to_task). ' +
+                'Alternative to --lifecycle-definition.',
+        }),
     };
     async run() {
         this.requireAuth();
@@ -260,8 +273,27 @@ class TasksCreate extends base_command_1.BaseCommand {
                 retryable: false,
             });
         }
+        // Resolve `--label-id` names before the create so a typo fails here, with
+        // the near misses named, rather than reaching the server as an id it will
+        // reject with no idea what was meant. Ids pass through untouched.
+        let resolvedLabelIds;
+        try {
+            const ids = await (0, label_ref_1.resolveLabelRefs)(flags['label-id'], {
+                applicableTo: 'task',
+                ...(process.env.OVERSKY_WORKSPACE_ID
+                    ? { workspaceId: process.env.OVERSKY_WORKSPACE_ID }
+                    : {}),
+            });
+            resolvedLabelIds = ids.length > 0 ? ids : undefined;
+        }
+        catch (err) {
+            if (err instanceof label_ref_1.LabelRefError)
+                this.error(err.message, { exit: 1 });
+            this.handleApiError(err);
+        }
         const payload = (0, tasks_1.buildTaskCreatePayload)(body, {
             ...flags,
+            'label-id': resolvedLabelIds,
             expectations: parsedExpectations.ok && parsedExpectations.value.length > 0
                 ? parsedExpectations.value
                 : undefined,

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

@@ -15,7 +15,19 @@ export default class TasksExpectationsAssess extends BaseCommand {
         evidence: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         '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>;
     };
+    /**
+     * 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.
+     */
+    private awaitingIds;
     run(): Promise<void>;
 }