@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/followups/resolve.d.ts

@@ -0,0 +1,23 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr followups resolve <id>` — settle with the honest outcome.
+ *
+ * Distinct from `cancel` on purpose: "the thing I was waiting for happened"
+ * (`resolved`) and "never mind" (`abandoned`) are different facts, and a
+ * system that cannot tell them apart cannot tell a working watch from a
+ * pointless one. The runtime's own terminals (expired/exhausted/escalated)
+ * are not accepted here.
+ */
+export default class FollowupsResolve extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        outcome: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        note: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/followups/resolve.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const followups_1 = require("../../lib/followups");
+/**
+ * `skrr followups resolve <id>` — settle with the honest outcome.
+ *
+ * Distinct from `cancel` on purpose: "the thing I was waiting for happened"
+ * (`resolved`) and "never mind" (`abandoned`) are different facts, and a
+ * system that cannot tell them apart cannot tell a working watch from a
+ * pointless one. The runtime's own terminals (expired/exhausted/escalated)
+ * are not accepted here.
+ */
+class FollowupsResolve extends base_command_1.BaseCommand {
+    static description = 'Settle a follow-up with its honest outcome — resolved (it paid off) or abandoned (never mind; `cancel` is the shortcut)';
+    static examples = [
+        '<%= config.bin %> followups resolve fu_abc --outcome resolved --note "the deploy landed"',
+        '<%= config.bin %> followups resolve fu_abc --outcome abandoned --note "no longer needed"',
+    ];
+    static args = {
+        id: followups_1.followUpIdArg,
+    };
+    static flags = {
+        outcome: core_1.Flags.string({
+            description: 'How it ended',
+            options: [...followups_1.FOLLOWUP_RESOLVE_OUTCOMES],
+            required: true,
+        }),
+        note: core_1.Flags.string({ description: 'What happened, for the audit' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(FollowupsResolve);
+        let result;
+        try {
+            result = (await followups_1.followupsApi.resolve(args.id, {
+                outcome: flags.outcome,
+                ...(flags.note ? { note: flags.note } : {}),
+            }));
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(`Follow-up ${args.id} settled: ${flags.outcome}.`);
+    }
+}
+exports.default = FollowupsResolve;

package/dist/commands/followups/show.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base-command';
+/** `skrr followups show <id>` — one follow-up, the same shape as the list rows. */
+export default class FollowupsShow extends BaseCommand {
+    static description: string;
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/followups/show.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const followups_1 = require("../../lib/followups");
+/** `skrr followups show <id>` — one follow-up, the same shape as the list rows. */
+class FollowupsShow extends base_command_1.BaseCommand {
+    static description = 'Show one follow-up';
+    static args = {
+        id: followups_1.followUpIdArg,
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(FollowupsShow);
+        let response;
+        try {
+            response = await followups_1.followupsApi.show(args.id);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const row = response.followup;
+        this.log((0, followups_1.followupSummaryLine)(row));
+        for (const [label, value] of [
+            ['says', row.content],
+            ['why', row.why],
+            ['intent', row.intentKey],
+            ['producer', row.producer],
+            ['terminal', row.terminal ? `${row.terminal} (${row.terminalReason ?? '—'})` : undefined],
+            ['deadline', row.deadlineAt],
+            ['escalated to', row.escalatedInitiativeId],
+        ]) {
+            if (value)
+                this.log(`    ${label}: ${value}`);
+        }
+    }
+}
+exports.default = FollowupsShow;

package/dist/commands/followups/watch.d.ts

@@ -0,0 +1,51 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr followups watch` — a `watch` follow-up: keep an eye on an
+ * asynchronous tail until a condition settles or a stop fires.
+ *
+ * Two forms, matching the service vocabulary exactly:
+ *
+ *   predicate  `--url` + `--until <json>` — a machine-settled observation of
+ *              an HTTPS endpoint. Free (no agent turn per check), termination
+ *              guaranteed by `--deadline`. Prefer this when the thing watched
+ *              is a URL whose response can answer the question.
+ *   recipe     `--check` + `--success` + `--abort` + `--wait <kind>` — a
+ *              deterministic check a future agent turn runs. One turn per
+ *              check; the abort criterion is mandatory because a watch that
+ *              cannot stop is a leak.
+ */
+export default class FollowupsWatch extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        subject: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        why: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        url: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        until: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        grant: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        deadline: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'check-every': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'max-checks': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'root-path': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'resume-prompt': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        check: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        success: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        abort: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        wait: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-at': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-entity': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-event': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-filter-field': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-filter-mode': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-filter-value': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-interval-seconds': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-max-attempts': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'wait-fallback': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        endpoint: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'endpoint-target': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        pin: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/followups/watch.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const followups_1 = require("../../lib/followups");
+const agent_resolver_1 = require("../../lib/agent-resolver");
+const triggers_1 = require("../../lib/triggers");
+/**
+ * `skrr followups watch` — a `watch` follow-up: keep an eye on an
+ * asynchronous tail until a condition settles or a stop fires.
+ *
+ * Two forms, matching the service vocabulary exactly:
+ *
+ *   predicate  `--url` + `--until <json>` — a machine-settled observation of
+ *              an HTTPS endpoint. Free (no agent turn per check), termination
+ *              guaranteed by `--deadline`. Prefer this when the thing watched
+ *              is a URL whose response can answer the question.
+ *   recipe     `--check` + `--success` + `--abort` + `--wait <kind>` — a
+ *              deterministic check a future agent turn runs. One turn per
+ *              check; the abort criterion is mandatory because a watch that
+ *              cannot stop is a leak.
+ */
+class FollowupsWatch extends base_command_1.BaseCommand {
+    static description = 'Watch an asynchronous tail until it settles — the watch follow-up';
+    static examples = [
+        '<%= config.bin %> followups watch --subject task:OSK-42 --why "deploy still running" --url https://ci.example.com/api/build/9 --until \'{"path":"status","op":"equals","value":"done"}\' --deadline 6h',
+        '<%= config.bin %> followups watch --subject task:OSK-42 --why "pr review" --check "gh pr view 42 --json state" --success "state == MERGED" --abort "state == CLOSED" --wait event --wait-entity github --wait-event pull_request_merged --wait-fallback 2h',
+        '<%= config.bin %> followups watch --subject conversation:abc --why "vendor reply" --check "check inbox" --success "reply arrived" --abort "3 days" --wait clock --wait-at 2026-09-20T09:00:00Z',
+    ];
+    static flags = {
+        subject: core_1.Flags.string({ description: 'Subject ref: type:externalKey', required: true }),
+        why: core_1.Flags.string({ description: 'Why this watch exists, in one line', required: true }),
+        agent: core_1.Flags.string({ description: 'Agent ID (default: bound session agent)' }),
+        // predicate form
+        url: core_1.Flags.string({ description: 'HTTPS endpoint to observe (predicate form)' }),
+        until: core_1.Flags.string({
+            description: 'Predicate tree as JSON (predicate form): a leaf {"path","op","value"} or {"all"|"any": [...]}. op is equals, not_equals, contains, starts_with, in, gt, lt, exists, … — an unknown op is refused with the full list',
+        }),
+        grant: core_1.Flags.string({ description: 'Grant id supplying the watch credentials' }),
+        deadline: core_1.Flags.string({ description: 'When the watch must stop (predicate form, required)' }),
+        'check-every': core_1.Flags.string({ description: 'Observation interval (predicate form)' }),
+        'max-checks': core_1.Flags.integer({ description: 'Observation cap (predicate form)' }),
+        'root-path': core_1.Flags.string({ description: 'JSON root path inside the response' }),
+        'resume-prompt': core_1.Flags.string({ description: 'What to tell the settling turn' }),
+        // recipe form
+        check: core_1.Flags.string({ description: 'The deterministic check to run (recipe form)' }),
+        success: core_1.Flags.string({ description: 'What state means the wait resolved (recipe form)' }),
+        abort: core_1.Flags.string({ description: 'When to stop and escalate (recipe form)' }),
+        wait: core_1.Flags.string({
+            description: 'Wait kind (recipe form)',
+            options: [...followups_1.WATCH_WAIT_KINDS],
+        }),
+        'wait-at': core_1.Flags.string({ description: 'Instant/duration for --wait clock' }),
+        'wait-entity': core_1.Flags.string({ description: 'Entity type for --wait event' }),
+        'wait-event': core_1.Flags.string({ description: 'Event type for --wait event' }),
+        'wait-filter-field': core_1.Flags.string({ description: 'Payload field for an event filter' }),
+        'wait-filter-mode': core_1.Flags.string({
+            description: 'Event filter mode',
+            options: ['equals', 'contains', 'in_set'],
+        }),
+        'wait-filter-value': core_1.Flags.string({ description: 'Event filter value' }),
+        'wait-interval-seconds': core_1.Flags.integer({ description: 'Poll interval for --wait poll_until' }),
+        'wait-max-attempts': core_1.Flags.integer({ description: 'Attempt cap for --wait poll_until' }),
+        'wait-fallback': core_1.Flags.string({
+            description: 'SLA backstop — required for --wait event (an event may never arrive), optional for poll_until',
+        }),
+        // delivery
+        endpoint: core_1.Flags.string({ description: 'Delivery endpoint id (EndpointRegistry)' }),
+        'endpoint-target': core_1.Flags.string({ description: 'Channel target for channel endpoints' }),
+        pin: core_1.Flags.string({ description: 'Conversation id the watch was authored in' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(FollowupsWatch);
+        let agent;
+        try {
+            agent = (0, followups_1.resolveFollowUpAgent)(flags.agent);
+        }
+        catch (err) {
+            const failure = (0, agent_resolver_1.agentResolutionFailure)(err);
+            this.failWithCliError({
+                message: failure.message,
+                code: failure.code,
+                exit: 2,
+                retryable: false,
+                details: { suggestion: failure.suggestion, context: failure.details },
+            });
+        }
+        const predicate = flags.url !== undefined || flags.until !== undefined;
+        const recipe = flags.check !== undefined || flags.success !== undefined || flags.abort !== undefined;
+        if (predicate && recipe) {
+            this.failWithCliError({
+                message: 'Predicate and recipe flags cannot mix. A watch is either an observed URL (--url/--until) or a checked recipe (--check/--success/--abort/--wait).',
+                code: 'FOLLOWUP_INVALID_FORM',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        if (!predicate && !recipe) {
+            this.failWithCliError({
+                message: 'A watch needs a form: --url + --until for a predicate watch, or --check + --success + --abort + --wait for a recipe watch.',
+                code: 'FOLLOWUP_INVALID_FORM',
+                exit: 2,
+                retryable: false,
+            });
+        }
+        const body = {
+            kind: 'watch',
+            producer: agent.boundToSession ? 'agent_in_turn' : 'user_explicit',
+            agentId: agent.id,
+            subject: (0, followups_1.parseSubjectRef)(flags.subject),
+            why: flags.why,
+            ...(flags.endpoint ? { endpointId: flags.endpoint } : {}),
+            ...(flags['endpoint-target'] ? { endpointTarget: flags['endpoint-target'] } : {}),
+            ...(flags.pin ? { pinnedConversationId: flags.pin } : {}),
+        };
+        if (predicate) {
+            if (!flags.url || !flags.until) {
+                this.failWithCliError({
+                    message: 'A predicate watch needs both --url <https> and --until <predicate-json>.',
+                    code: 'FOLLOWUP_KIND_FIELD_MISSING',
+                    exit: 2,
+                    retryable: false,
+                });
+            }
+            if (!flags.deadline) {
+                this.failWithCliError({
+                    message: '--deadline is required — a watch that cannot stop is a leak.',
+                    code: 'FOLLOWUP_KIND_FIELD_MISSING',
+                    exit: 2,
+                    retryable: false,
+                });
+            }
+            Object.assign(body, {
+                form: 'predicate',
+                url: flags.url,
+                until: (0, triggers_1.parseJsonObject)(flags.until, '--until'),
+                grantId: flags.grant,
+                deadline: flags.deadline,
+                checkEvery: flags['check-every'],
+                maxChecks: flags['max-checks'],
+                rootPath: flags['root-path'],
+                resumePrompt: flags['resume-prompt'],
+            });
+        }
+        else {
+            for (const field of ['check', 'success', 'abort', 'wait']) {
+                if (!flags[field]) {
+                    this.failWithCliError({
+                        message: `A recipe watch needs --${field}.`,
+                        code: 'FOLLOWUP_KIND_FIELD_MISSING',
+                        exit: 2,
+                        retryable: false,
+                    });
+                }
+            }
+            const wait = { kind: flags.wait };
+            if (flags.wait === 'clock') {
+                wait.at = flags['wait-at'];
+            }
+            else if (flags.wait === 'event') {
+                Object.assign(wait, {
+                    entityType: flags['wait-entity'],
+                    eventType: flags['wait-event'],
+                    filterField: flags['wait-filter-field'],
+                    filterMode: flags['wait-filter-mode'],
+                    filterValue: flags['wait-filter-value'],
+                    fallback: flags['wait-fallback'],
+                });
+            }
+            else {
+                Object.assign(wait, {
+                    intervalSeconds: flags['wait-interval-seconds'],
+                    maxAttempts: flags['wait-max-attempts'],
+                    fallback: flags['wait-fallback'],
+                });
+            }
+            Object.assign(body, {
+                form: 'recipe',
+                check: flags.check,
+                success: flags.success,
+                abort: flags.abort,
+                wait,
+            });
+        }
+        let response;
+        try {
+            response = await followups_1.followupsApi.create(body);
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        const row = response.followup;
+        if (response.reused) {
+            this.log(`Already armed: ${row?.id} — an identical watch exists and was not duplicated.`);
+            return;
+        }
+        if (response.dropped) {
+            this.log('Dropped by the daily watch budget — no watch was armed.');
+            return;
+        }
+        this.log(`Watch armed: ${row?.id}${row?.deadlineAt ? `, deadline ${row.deadlineAt}` : ''}.`);
+    }
+}
+exports.default = FollowupsWatch;

package/dist/commands/goals/labels/add.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");
 class GoalsLabelsAdd extends base_command_1.BaseCommand {
     static description = 'Attach a label to a goal';
     static examples = [
@@ -15,7 +16,7 @@ class GoalsLabelsAdd extends base_command_1.BaseCommand {
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output the updated goal as JSON' }),
         label: core_1.Flags.string({
-            description: 'Label ID — must be applicable to goals (see `skrr labels list --applicable-to goal`)',
+            description: 'Label — id, or a name from `skrr labels list --applicable-to goal`. An unknown name is refused, never created.',
             required: true,
         }),
     };
@@ -25,9 +26,25 @@ class GoalsLabelsAdd extends base_command_1.BaseCommand {
         // `goals update` deliberately refuses labelIds — the server routes label
         // changes through this atomic endpoint so exclusive-group eviction and
         // usage counters stay correct. Re-attaching an attached label is a no-op.
+        // 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: 'goal',
+                ...(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.addLabelToGoal({ goalId: args.id, labelId: flags.label });
+            result = await data_provider_1.dataService.addLabelToGoal({ goalId: args.id, labelId });
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/goals/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");
 class GoalsLabelsRemove extends base_command_1.BaseCommand {
     static description = 'Detach a label from a goal';
     static examples = [
@@ -14,16 +15,35 @@ class GoalsLabelsRemove extends base_command_1.BaseCommand {
     };
     static flags = {
         json: core_1.Flags.boolean({ description: 'Output the updated goal 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 goal`. An unknown name is refused, never created.',
+            required: true,
+        }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(GoalsLabelsRemove);
         // 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 goal.
+        // 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: 'goal',
+                ...(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.removeLabelFromGoal({ goalId: args.id, labelId: flags.label });
+            result = await data_provider_1.dataService.removeLabelFromGoal({ goalId: args.id, labelId });
         }
         catch (err) {
             this.handleApiError(err);

package/dist/commands/harnesses/forget.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@oclif/core");
 const base_command_1 = require("../../base-command");
 const harnesses_1 = require("../../lib/harnesses");
+const api_fetch_1 = require("../../lib/api-fetch");
+const show_1 = require("./show");
 /**
  * Forget an harness — `forget`, not `delete`.
  *
@@ -26,6 +28,24 @@ class HarnessesForget extends base_command_1.BaseCommand {
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(HarnessesForget);
+        // Refuse a reference that cannot name a harness BEFORE asking anything.
+        //
+        // The confirmation used to run first, so `harnesses forget notanid` asked
+        // whether to delete something that could never exist, and a scripted caller
+        // who added `--yes` to get past it then hit a second, different failure:
+        // a bare `Invalid harness ID / HTTP_400` from the server. Two round trips
+        // for one typo, on the command where a typo matters most.
+        //
+        // The sibling `harnesses show` already explains this class of mistake
+        // (`describeWrongHarnessRef` names which KIND of id you passed and which
+        // command takes it). `forget` is the DESTRUCTIVE one and had the worse
+        // message; it now shares the explanation.
+        if (!/^[0-9a-f]{24}$/i.test(args.harness.trim())) {
+            this.error(`Not a harness id: ${args.harness}\n${(0, show_1.describeWrongHarnessRef)(args.harness)}`, {
+                exit: 1,
+            });
+            return;
+        }
         // Name it before removing it. An id alone does not tell the operator which
         // of their machines they are about to drop from the fleet.
         if (!flags.yes) {
@@ -52,6 +72,14 @@ class HarnessesForget extends base_command_1.BaseCommand {
             this.log(`Forgot ${args.harness}.`);
         }
         catch (err) {
+            // A well-formed id the server still rejects: say so in the same words
+            // `show` uses, rather than relaying `Invalid harness ID`.
+            if (err instanceof api_fetch_1.ApiFetchError && err.status === 400) {
+                this.error(`Not a harness id: ${args.harness}\n${(0, show_1.describeWrongHarnessRef)(args.harness)}`, {
+                    exit: 1,
+                });
+                return;
+            }
             this.handleApiError(err);
         }
     }

package/dist/commands/harnesses/install.d.ts

@@ -0,0 +1,41 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Install one managed coding-agent CLI on a machine.
+ *
+ * ## Why this did not exist
+ *
+ * The daemon has installed any of seven providers since `d878b79581`, and
+ * `POST /api/daemons/:id/cli-installers/:provider/install` is the request the
+ * web app's Install button sends. From the CLI only ONE of them was reachable:
+ * `skrr code install`, whose provider is a constant. Everything else had to be
+ * installed by hand, or from the web app.
+ *
+ * `skrr harnesses install-token` made that worse rather than neutral. It is the
+ * only entry in `harnesses --help` with "install" in its name, so a user
+ * scanning for "how do I install a harness" lands on it — and it mints a daemon
+ * enrolment token for another machine, which is a different thing entirely.
+ *
+ * ## The provider name is validated here, against the shared vocabulary
+ *
+ * Unlike `harnesses list --provider`, where the set is open because a daemon
+ * registers a row per capability it detects, the INSTALLABLE set is closed and
+ * owned: `MANAGED_CLI_PROVIDER_IDS` in `@skrr-ai/data-provider`, which the
+ * daemon's own list is pinned against by `managedCliProviders.spec.ts`. So a
+ * typo can be rejected with the real options, rather than sent to the daemon to
+ * come back as an opaque refusal.
+ */
+export default class HarnessesInstall extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        provider: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        daemon: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /** What the daemon says about this provider right now, best effort. */
+    private installerNote;
+    private daemonIdFor;
+}