@skrr-ai/cli 0.1.101 → 0.1.103

package/dist/commands/followups/checkin.js

@@ -99,18 +99,32 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
             this.handleApiError(err);
             return;
         }
+        const producer = agent.boundToSession ? 'agent_in_turn' : 'user_explicit';
+        // An explicit request from a person that arms nothing is a refusal, and a script reading the
+        // exit code must see it as one (OSK-15413). A check-in the AGENT chose to make is different:
+        // there, staying quiet when the budget is spent is the designed outcome.
+        if (response.dropped && producer === 'user_explicit') {
+            this.failWithCliError({
+                message: budgetRefusalMessage(agent.id, response.budget),
+                code: 'FOLLOWUP_BUDGET_EXHAUSTED',
+                exit: 1,
+                retryable: false,
+                details: { budget: response.budget ?? null, response },
+            });
+            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} — one pending check-in per conversation, and this is it.`);
+            this.log(reusedMessage(row, subject, flags.why));
             return;
         }
         if (response.dropped) {
-            // silent_drop is the check-in budget's contract: the answer to "one
-            // greeting too many" is quiet, not an error the caller can retry.
+            // silent_drop is the check-in budget's contract for an agent's own check-in: the answer to
+            // "one greeting too many" is quiet, not an error the caller can retry.
             this.log('Dropped by the daily check-in budget — staying quiet is the correct outcome.');
             return;
         }
@@ -118,3 +132,32 @@ class FollowupsCheckin extends base_command_1.BaseCommand {
     }
 }
 exports.default = FollowupsCheckin;
+/**
+ * What a reused answer means for the person who asked: a second check-in on a subject that already
+ * has one arms nothing and changes nothing, so the note and time they typed were NOT applied. Say
+ * so, show what is armed, and name the two ways forward (OSK-15411). Exit stays 0: the follow-up
+ * they wanted to exist does exist.
+ */
+function reusedMessage(row, subject, requestedWhy) {
+    const lines = [
+        `Already armed: ${row?.id} — one pending check-in per subject (${subject.type}:${subject.externalKey}), and this is it.`,
+        'Nothing in this request was applied: it armed no new check-in and changed neither the note nor the time.',
+    ];
+    if (row) {
+        const sameNote = row.why === requestedWhy;
+        lines.push(`Armed: ${row.why ? `"${row.why}"` : '(no note)'}, next ${row.nextRunAt ?? 'when its schedule says'}${sameNote ? ' (the same note you gave)' : ''}.`);
+    }
+    lines.push(`To change the time: skrr followups reschedule ${row?.id ?? '<id>'} --at <instant> or --in <offset>.`, "To change the note: cancel it and create it again (a cancelled check-in still counts against today's check-in budget).");
+    return lines.join('\n');
+}
+/** The refusal for an explicit check-in the daily budget will not take, with the number and the way to raise it. */
+function budgetRefusalMessage(agentId, budget) {
+    const { used, limit } = (budget && typeof budget === 'object' ? budget : {});
+    const spent = typeof used === 'number' && typeof limit === 'number'
+        ? `${agentId} has used ${used} of its ${limit} check-ins today`
+        : `${agentId} has used its daily check-in budget`;
+    return [
+        `No check-in was armed: ${spent}. The day resets at 00:00 UTC, and a cancelled check-in still counts.`,
+        `Raise the limit with: skrr agents triggers policy ${agentId} --followup-budget checkin=<count>`,
+    ].join(' ');
+}

package/dist/commands/machines/dedicated/exec.js

@@ -104,7 +104,9 @@ class DedicatedMachinesExec extends base_command_1.BaseCommand {
             description: `How long to let it run, such as 30s or 5m (default 2m, max ${dedicated_machines_1.DEDICATED_EXEC_MAX_TIMEOUT_MS / 60000}m). The process group is killed at the deadline.`,
         }),
         'request-id': core_1.Flags.string({
-            description: 'Idempotency key for this command. Repeating the invocation with the same id returns the run it already started (and its output, for 5 minutes after it ends) instead of running it again. Letters, digits and . _ : / - only.',
+            description: 'Idempotency key for this command. Repeating the invocation with the same id returns the run it already started instead of running it again. ' +
+                'Output is kept for at most 5 minutes after it ends and at most 60 seconds after the first terminal read, whichever expires sooner. ' +
+                'Letters, digits and . _ : / - only.',
         }),
         workspace: core_1.Flags.string({ description: 'Workspace scope' }),
         json: core_1.Flags.boolean({ description: 'Output the result as JSON' }),

package/dist/commands/proposals/discard.d.ts

@@ -1,5 +1,9 @@
 import { ProposalDecisionCommand } from '../../lib/proposal-decision-command';
 export default class ProposalsDiscard extends ProposalDecisionCommand {
     static description: string;
+    static args: {
+        kind: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static decision: "discard";
 }

package/dist/commands/proposals/discard.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const proposal_decision_command_1 = require("../../lib/proposal-decision-command");
 class ProposalsDiscard extends proposal_decision_command_1.ProposalDecisionCommand {
     static description = 'Discard one displayed proposal through its domain authority';
+    // Own, not inherited: oclif spreads the command class into the parser input, and a static a
+    // subclass only inherits is dropped, which left these commands with no declared KIND/ID (OSK-15346).
+    static args = proposal_decision_command_1.ProposalDecisionCommand.args;
     static decision = 'discard';
 }
 exports.default = ProposalsDiscard;

package/dist/commands/proposals/keep.d.ts

@@ -1,5 +1,9 @@
 import { ProposalDecisionCommand } from '../../lib/proposal-decision-command';
 export default class ProposalsKeep extends ProposalDecisionCommand {
     static description: string;
+    static args: {
+        kind: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static decision: "keep";
 }

package/dist/commands/proposals/keep.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const proposal_decision_command_1 = require("../../lib/proposal-decision-command");
 class ProposalsKeep extends proposal_decision_command_1.ProposalDecisionCommand {
     static description = 'Keep one displayed proposal through its domain authority';
+    // Own, not inherited: oclif spreads the command class into the parser input, and a static a
+    // subclass only inherits is dropped, which left these commands with no declared KIND/ID (OSK-15346).
+    static args = proposal_decision_command_1.ProposalDecisionCommand.args;
     static decision = 'keep';
 }
 exports.default = ProposalsKeep;

package/dist/commands/proposals/snooze.d.ts

@@ -1,5 +1,9 @@
 import { ProposalDecisionCommand } from '../../lib/proposal-decision-command';
 export default class ProposalsSnooze extends ProposalDecisionCommand {
     static description: string;
+    static args: {
+        kind: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static decision: "snooze";
 }

package/dist/commands/proposals/snooze.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const proposal_decision_command_1 = require("../../lib/proposal-decision-command");
 class ProposalsSnooze extends proposal_decision_command_1.ProposalDecisionCommand {
     static description = 'Snooze one displayed proposal through its domain authority';
+    // Own, not inherited: oclif spreads the command class into the parser input, and a static a
+    // subclass only inherits is dropped, which left these commands with no declared KIND/ID (OSK-15346).
+    static args = proposal_decision_command_1.ProposalDecisionCommand.args;
     static decision = 'snooze';
 }
 exports.default = ProposalsSnooze;

package/dist/commands/spaces/workflows/cancel-node.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../../base-command';
+export default class SpacesWorkflowsCancelNode extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        spaceId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        runId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        nodeKey: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        'from-json': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        reason: 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/spaces/workflows/cancel-node.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const prompt_1 = require("../../../lib/prompt");
+const workflow_node_control_1 = require("../../../lib/workflow-node-control");
+class SpacesWorkflowsCancelNode extends base_command_1.BaseCommand {
+    static description = 'Request cancellation of one exact workflow node attempt and show the returned execution state';
+    static examples = [
+        '<%= config.bin %> spaces workflows run <space> <run> --json > reviewed-run.json',
+        '<%= config.bin %> spaces workflows cancel-node <space> <run> <node> --from-json reviewed-run.json',
+    ];
+    static args = {
+        spaceId: core_1.Args.string({ description: 'Owning Space ID', required: true, ignoreStdin: true }),
+        runId: core_1.Args.string({ description: 'Workflow run ID', required: true, ignoreStdin: true }),
+        nodeKey: core_1.Args.string({ description: 'Node key to stop', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        'from-json': core_1.Flags.string({ description: 'Saved canonical workflow run snapshot, or - for stdin', required: true }),
+        reason: core_1.Flags.string({ description: 'Cancellation reason (at most 500 characters)' }),
+        json: core_1.Flags.boolean({ description: 'Output the updated workflow run as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(SpacesWorkflowsCancelNode);
+        try {
+            const body = (0, workflow_node_control_1.nodeCancellationFromSnapshot)(args.spaceId, args.runId, args.nodeKey, await (0, prompt_1.readJsonBody)(flags['from-json']), flags.reason);
+            const run = await data_provider_1.dataService.cancelSpaceWorkflowNode(args.spaceId, args.runId, args.nodeKey, body);
+            if (flags.json) {
+                this.log(JSON.stringify(run, null, 2));
+                return;
+            }
+            const node = run.nodes?.find((item) => item.nodeKey === args.nodeKey);
+            this.log(`Cancellation for ${args.nodeKey}: ${node?.cancellation?.state ?? 'unknown'}.`);
+            this.log(`Returned node state: ${node?.status ?? 'unknown'}.`);
+            this.log(`Workflow run ${run.id}: ${run.status}.`);
+        }
+        catch (error) {
+            this.handleApiError(error);
+        }
+    }
+}
+exports.default = SpacesWorkflowsCancelNode;

package/dist/commands/spaces/workflows/cancel.d.ts

@@ -1,4 +1,43 @@
 import { BaseCommand } from '../../../base-command';
+/**
+ * Child workflow runs a cancelled run was waiting on. A cancelled node keeps its `waitingFor`,
+ * and every node kind that starts a child run (`workflow_call` = subworkflow, `loop` iteration,
+ * `task_plan`) records that run as `waitingFor.workflowRunId`. Reading the id rather than the
+ * kind means a new child-starting node kind is not silently missed.
+ */
+export declare function childWorkflowRunIds(run: {
+    id?: string;
+    nodes?: Array<{
+        waitingFor?: unknown;
+    }>;
+}): string[];
+/**
+ * Lines for a cancel that has not finished converging. `cancellation.state: settled` with
+ * nothing pending is the only converged answer; anything else must not read as "stopped".
+ */
+export declare function describeCancellationProgress(spaceId: string, run: {
+    id: string;
+    cancellation?: {
+        state?: string;
+        descendantsPending?: boolean;
+        executorsPending?: number;
+    };
+}): string[];
+/**
+ * The lines that tell a person which child runs a `preserve_children` cancel left running.
+ * "Cancelled" next to a child that is still waiting forever is the part nobody could see
+ * (OSK-15331), so say it and say how to stop them. Re-cancelling the parent with
+ * `--scope subtree` widens the stop to every descendant (the server persists the wider
+ * decision before touching any descendant). An unreadable child is reported as unreadable,
+ * never as stopped.
+ */
+export declare function describePreservedChildren(spaceId: string, parentRunId: string, children: Array<{
+    id: string;
+    status?: string;
+    unreadable?: boolean;
+}>, { reviewedScope }?: {
+    reviewedScope?: boolean;
+}): string[];
 export default class SpacesWorkflowsCancel extends BaseCommand {
     static description: string;
     static args: {
@@ -7,6 +46,7 @@ export default class SpacesWorkflowsCancel extends BaseCommand {
     };
     static flags: {
         json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;

package/dist/commands/spaces/workflows/cancel.js

@@ -1,10 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.childWorkflowRunIds = childWorkflowRunIds;
+exports.describeCancellationProgress = describeCancellationProgress;
+exports.describePreservedChildren = describePreservedChildren;
 const core_1 = require("@oclif/core");
 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 CANCELLATION_SCOPES = [
+    'preserve_children',
+    'subtree',
+];
+/**
+ * Child workflow runs a cancelled run was waiting on. A cancelled node keeps its `waitingFor`,
+ * and every node kind that starts a child run (`workflow_call` = subworkflow, `loop` iteration,
+ * `task_plan`) records that run as `waitingFor.workflowRunId`. Reading the id rather than the
+ * kind means a new child-starting node kind is not silently missed.
+ */
+function childWorkflowRunIds(run) {
+    const ids = new Set();
+    for (const node of run.nodes ?? []) {
+        const waitingFor = node.waitingFor;
+        const childId = waitingFor?.workflowRunId;
+        if (typeof childId === 'string' && childId && childId !== run.id)
+            ids.add(childId);
+    }
+    return [...ids];
+}
+/**
+ * Lines for a cancel that has not finished converging. `cancellation.state: settled` with
+ * nothing pending is the only converged answer; anything else must not read as "stopped".
+ */
+function describeCancellationProgress(spaceId, run) {
+    const c = run.cancellation;
+    if (!c)
+        return [];
+    const pending = c.state !== 'settled' || c.descendantsPending || Number(c.executorsPending) > 0;
+    if (!pending)
+        return [];
+    const detail = `state ${c.state ?? 'unknown'}, descendant runs pending: ${c.descendantsPending ? 'yes' : 'no'}, executors pending: ${Number(c.executorsPending) || 0}`;
+    // `failed` means the cleanup gave up: reading again never converges it, only a reconcile retries.
+    if (c.state === 'failed') {
+        return [
+            `Cancellation cleanup gave up (${detail}).`,
+            `  Retry it with: skrr spaces workflows reconcile ${spaceId} ${run.id}`,
+        ];
+    }
+    return [
+        `Cancellation is still converging (${detail}).`,
+        `  Re-read it with: skrr spaces workflows run ${spaceId} ${run.id}`,
+    ];
+}
+/**
+ * The lines that tell a person which child runs a `preserve_children` cancel left running.
+ * "Cancelled" next to a child that is still waiting forever is the part nobody could see
+ * (OSK-15331), so say it and say how to stop them. Re-cancelling the parent with
+ * `--scope subtree` widens the stop to every descendant (the server persists the wider
+ * decision before touching any descendant). An unreadable child is reported as unreadable,
+ * never as stopped.
+ */
+function describePreservedChildren(spaceId, parentRunId, children, { reviewedScope = false } = {}) {
+    const live = children.filter((child) => child.unreadable || (0, data_provider_1.isActiveWorkflowRunStatus)(child.status));
+    if (live.length === 0)
+        return [];
+    const lines = [
+        `Left running (scope preserve_children): ${live.length} child workflow run${live.length === 1 ? '' : 's'} started by this run.`,
+    ];
+    for (const child of live) {
+        lines.push(`  ${child.id} (${child.unreadable ? 'status unreadable' : child.status})`);
+    }
+    if (reviewedScope) {
+        // A stop under a reviewed scope is frozen to that review, so cancelling the parent again
+        // does not widen it; each child is stopped on its own.
+        lines.push(`This run was stopped under a reviewed scope, so cancelling it again will not widen the stop.`, `Stop a child with: skrr spaces workflows cancel ${spaceId} <child-run-id> --scope subtree --yes`);
+        return lines;
+    }
+    lines.push(`Stop them now: skrr spaces workflows cancel ${spaceId} ${parentRunId} --scope subtree --yes`, `  (widens this cancel to every descendant run), or stop one: skrr spaces workflows cancel ${spaceId} <child-run-id> --scope subtree --yes`);
+    return lines;
+}
 class SpacesWorkflowsCancel extends base_command_1.BaseCommand {
     static description = 'Cancel a workflow run and stop further graph coordination';
     static args = {
@@ -12,15 +86,25 @@ class SpacesWorkflowsCancel extends base_command_1.BaseCommand {
         runId: core_1.Args.string({ description: 'Workflow run ID', required: true, ignoreStdin: true }),
     };
     static flags = {
-        json: core_1.Flags.boolean({ description: 'Output the cancelled run as JSON' }),
+        json: core_1.Flags.boolean({
+            description: 'Output the cancelled run as JSON (cancellation.scope and the waitingFor.workflowRunId of the cancelled nodes show which child runs were left running)',
+        }),
+        scope: core_1.Flags.string({
+            description: 'What happens to child workflow runs this run started: preserve_children (default) leaves them running, subtree stops every descendant run too',
+            options: [...CANCELLATION_SCOPES],
+        }),
         yes: core_1.Flags.boolean({ char: 'y', description: 'Skip confirmation prompt' }),
     };
     async run() {
         this.requireAuth();
         const { args, flags } = await this.parse(SpacesWorkflowsCancel);
+        const scope = flags.scope;
         let confirmed;
         try {
-            confirmed = await (0, prompt_1.confirmDestructive)(`Cancel workflow run ${args.runId}? This stops workflow coordination; already-dispatched task execution may continue.`, flags.yes);
+            const scopeNote = scope === 'subtree'
+                ? ' Child workflow runs it started are cancelled too.'
+                : ' Child workflow runs it started keep running (--scope subtree stops them too).';
+            confirmed = await (0, prompt_1.confirmDestructive)(`Cancel workflow run ${args.runId}? This stops workflow coordination; already-dispatched task execution may continue.${scopeNote}`, flags.yes);
         }
         catch (error) {
             this.error(error.message, {
@@ -34,7 +118,7 @@ class SpacesWorkflowsCancel extends base_command_1.BaseCommand {
         }
         let run;
         try {
-            run = await data_provider_1.dataService.cancelSpaceWorkflowRun(args.spaceId, args.runId);
+            run = await data_provider_1.dataService.cancelSpaceWorkflowRun(args.spaceId, args.runId, scope ? { scope } : {});
         }
         catch (error) {
             this.handleApiError(error);
@@ -45,6 +129,28 @@ class SpacesWorkflowsCancel extends base_command_1.BaseCommand {
             return;
         }
         this.log(`Cancelled workflow run ${run.id} (${run.status}).`);
+        for (const line of describeCancellationProgress(args.spaceId, run))
+            this.log(line);
+        if ((run.cancellation?.scope ?? run.cancellationScope ?? scope) === 'subtree')
+            return;
+        const childIds = childWorkflowRunIds(run);
+        if (childIds.length === 0)
+            return;
+        const children = await Promise.all(childIds.map(async (id) => {
+            try {
+                const child = await data_provider_1.dataService.getSpaceWorkflowRun(args.spaceId, id);
+                return { id, status: child.status };
+            }
+            catch {
+                return { id, unreadable: true };
+            }
+        }));
+        const reviewedScope = Boolean(run.cancellationExpectedScope);
+        for (const line of describePreservedChildren(args.spaceId, run.id, children, {
+            reviewedScope,
+        })) {
+            this.log(line);
+        }
     }
 }
 exports.default = SpacesWorkflowsCancel;

package/dist/commands/spaces/workflows/run.d.ts

@@ -16,6 +16,15 @@ export declare function describeNodeAttention(node: {
         message?: string;
     } | null;
 }): string;
+export declare function describeLoopItemsNote(node: {
+    nodeKey?: unknown;
+    nodeType?: unknown;
+    output?: {
+        itemsStatus?: unknown;
+        itemsKey?: unknown;
+        itemsFoundType?: unknown;
+    } | null;
+}): string;
 export default class SpacesWorkflowsRun extends BaseCommand {
     static description: string;
     static args: {

package/dist/commands/spaces/workflows/run.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.describeNodeAttention = describeNodeAttention;
+exports.describeLoopItemsNote = describeLoopItemsNote;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
@@ -26,6 +27,38 @@ function describeNodeAttention(node) {
         return `${reason}: ${message}`;
     return reason || message || 'needs attention';
 }
+/**
+ * A note for a loop that succeeded having iterated nothing because its
+ * collection never arrived, or '' when there is nothing to say (OSK-15324).
+ *
+ * A zero-iteration loop is `succeeded`, so the plain table reads as healthy
+ * whether the list was legitimately empty or the value the author meant never
+ * reached the loop. The server records which on the node output; say it. An
+ * empty list is the legitimate case and stays silent.
+ */
+/** One printable line: control characters (an ESC sequence included) become spaces. */
+function oneLine(value) {
+    // eslint-disable-next-line no-control-regex
+    return (0, format_1.collapseWhitespace)(value.replace(/[\u0000-\u001f\u007f-\u009f]/g, ' '));
+}
+function describeLoopItemsNote(node) {
+    if (node.nodeType !== 'loop')
+        return '';
+    const output = node.output;
+    // `itemsKey` is author-chosen free text, unlike a node key, so it is printed the way the
+    // table prints a cell: one line, no control characters.
+    const key = oneLine(typeof output?.itemsKey === 'string' && output.itemsKey ? output.itemsKey : 'items');
+    const name = oneLine(String(node.nodeKey ?? 'loop'));
+    if (output?.itemsStatus === 'missing') {
+        return `${name}: ran 0 iterations because its input "${key}" was missing or null`;
+    }
+    if (output?.itemsStatus === 'not_array') {
+        const found = typeof output.itemsFoundType === 'string' ? output.itemsFoundType : 'a value';
+        const article = /^[aeiou]/i.test(found) ? 'an' : 'a';
+        return `${name}: ran 0 iterations because its input "${key}" was ${article} ${oneLine(found)}, not a list`;
+    }
+    return '';
+}
 class SpacesWorkflowsRun extends base_command_1.BaseCommand {
     static description = 'Inspect a workflow run and each durable node state';
     static args = {
@@ -84,6 +117,11 @@ class SpacesWorkflowsRun extends base_command_1.BaseCommand {
                     ? [{ key: 'attention', header: 'ATTENTION' }]
                     : []),
             ], (line) => this.log(line));
+            for (const node of nodes) {
+                const note = describeLoopItemsNote(node);
+                if (note)
+                    this.log(`Note: ${note}`);
+            }
         }
     }
 }

package/dist/commands/tasks/approvals/resolve.d.ts

@@ -1,4 +1,16 @@
+import { type TaskApprovalResolveParams } from '@skrr-ai/data-provider';
 import { BaseCommand } from '../../../base-command';
+/**
+ * The request body for resolving an approval. The server's field is `comment`
+ * (`TaskApprovalResolveParams`); `--reason` is only the flag's name. It was sent
+ * as `reason` through an `as unknown as` cast, so the type checker could not see
+ * the mismatch and the server's non-strict schema dropped the key: the command
+ * succeeded and the reason was stored nowhere (OSK-15362).
+ */
+export declare function approvalResolutionBody(flags: {
+    status: 'approved' | 'rejected';
+    reason?: string;
+}): TaskApprovalResolveParams;
 export default class TasksApprovalsResolve extends BaseCommand {
     static description: string;
     static examples: string[];

package/dist/commands/tasks/approvals/resolve.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.approvalResolutionBody = approvalResolutionBody;
 const core_1 = require("@oclif/core");
 const data_provider_1 = require("@skrr-ai/data-provider");
 const base_command_1 = require("../../../base-command");
+/**
+ * The request body for resolving an approval. The server's field is `comment`
+ * (`TaskApprovalResolveParams`); `--reason` is only the flag's name. It was sent
+ * as `reason` through an `as unknown as` cast, so the type checker could not see
+ * the mismatch and the server's non-strict schema dropped the key: the command
+ * succeeded and the reason was stored nowhere (OSK-15362).
+ */
+function approvalResolutionBody(flags) {
+    const body = { status: flags.status };
+    if (flags.reason)
+        body.comment = flags.reason;
+    return body;
+}
 class TasksApprovalsResolve extends base_command_1.BaseCommand {
     static description = 'Resolve (approve or reject) a task approval';
     static examples = [
@@ -27,15 +41,15 @@ class TasksApprovalsResolve extends base_command_1.BaseCommand {
         this.requireAuth();
         const { args, flags } = await this.parse(TasksApprovalsResolve);
         const taskRef = await this.resolveEntityRef('task', args.id);
-        const data = { status: flags.status };
-        if (flags.reason)
-            data.reason = flags.reason;
         let result;
         try {
             result = await data_provider_1.dataService.resolveTaskApproval({
                 taskId: taskRef,
                 approvalId: args.approvalId,
-                data: data,
+                data: approvalResolutionBody({
+                    status: flags.status,
+                    reason: flags.reason,
+                }),
             });
         }
         catch (err) {
@@ -46,7 +60,9 @@ class TasksApprovalsResolve extends base_command_1.BaseCommand {
             return;
         }
         const a = result;
-        this.log(`Approval ${a.id ?? a._id ?? args.approvalId} → ${flags.status}`);
+        // Say what was recorded, so a reason that was not stored cannot pass unseen.
+        const recorded = typeof a.comment === 'string' && a.comment ? ` (reason: ${a.comment})` : '';
+        this.log(`Approval ${a.id ?? a._id ?? args.approvalId} → ${flags.status}${recorded}`);
     }
 }
 exports.default = TasksApprovalsResolve;

package/dist/commands/tasks/schedule.js

@@ -28,7 +28,7 @@ class TasksSchedule extends base_command_1.BaseCommand {
             dependsOn: ['cron'],
         }),
         'max-runs': core_1.Flags.integer({
-            description: 'Cap total fires (recurring only)',
+            description: 'Cap total occurrences (recurring only): each scheduled fire counts, and so does an occurrence you complete by hand before the scheduler touches it',
             dependsOn: ['cron'],
         }),
         'end-date': core_1.Flags.string({

package/dist/commands/triggers/capabilities.js

@@ -37,6 +37,13 @@ class TriggersCapabilities extends base_command_1.BaseCommand {
             ? capabilities.templateVariables.map((v) => typeof v === 'object' && v !== null ? String(v.name) : String(v))
             : capabilities.templateVariableNames;
         this.log(`Template vars: ${Array.isArray(vars) ? vars.join(', ') : '-'}`);
+        // Some scopes cannot create a trigger until something else is set up, and the refusal
+        // otherwise arrives only after submitting.
+        const needs = capabilities.prerequisites;
+        if (Array.isArray(needs)) {
+            for (const need of needs)
+                this.log(`Needs: ${String(need)}`);
+        }
         // Beside the modes, because `external_work_task` is a mode that cannot be
         // authored without one of these.
         const contracts = capabilities.effectContracts;

package/dist/commands/triggers/create.js

@@ -20,7 +20,10 @@ class TriggersCreate extends base_command_1.BaseCommand {
         'from-json': core_1.Flags.string({
             description: 'Path to a JSON file (or "-" for stdin) to use as the request body',
         }),
-        scope: core_1.Flags.string({ description: 'Trigger scope kind', options: [...triggers_1.TRIGGER_SCOPE_KINDS] }),
+        scope: core_1.Flags.string({
+            description: 'Trigger scope kind. A scope can have prerequisites (a space_oracle Space needs a Leader agent): `triggers capabilities <scope>` lists them under "Needs"',
+            options: [...triggers_1.TRIGGER_SCOPE_KINDS],
+        }),
         ref: core_1.Flags.string({
             description: 'Scope ref as key=value (repeatable), for example --ref agentId=abc',
             multiple: true,
@@ -88,7 +91,9 @@ class TriggersCreate extends base_command_1.BaseCommand {
             multiple: true,
         }),
         timezone: core_1.Flags.string({ description: 'IANA timezone for schedule triggers' }),
-        'max-fires-per-day': core_1.Flags.integer({ description: 'Daily fire cap' }),
+        'max-fires-per-day': core_1.Flags.integer({
+            description: 'Daily fire cap (schedule, stochastic and self_scheduled triggers only)',
+        }),
         'max-runs': core_1.Flags.integer({ description: 'Lifetime fire cap for schedule triggers' }),
         'end-at': core_1.Flags.string({
             description: 'ISO-8601 datetime after which a schedule stops firing',
@@ -189,6 +194,9 @@ class TriggersCreate extends base_command_1.BaseCommand {
         let payload;
         try {
             payload = await (0, prompt_1.readJsonBody)(flags['from-json']);
+            // A flag for a kind other than --kind is refused, not dropped: the block it fills is not
+            // sent, so the caller would believe a limit was set that nothing holds (OSK-15491).
+            (0, triggers_1.assertKindFlagsApply)(flags.kind ?? payload.kind, flags);
             const refs = (0, triggers_1.parseKeyValueFlags)(flags.ref, '--ref', flags.scope ?? payload.scope?.kind);
             if (flags.scope || Object.keys(refs).length > 0) {
                 payload.scope = {
@@ -264,22 +272,8 @@ class TriggersCreate extends base_command_1.BaseCommand {
                 filterField: flags['filter-field'],
                 filterValues,
             });
-            (0, triggers_1.setDefined)(event, {
-                entityType: flags.entity,
-                eventType: flags.event,
-                filterMode: flags['filter-mode'],
-                filterField: flags['filter-field'],
-                filterValue: filterValues && filterValues.length > 1 ? filterValues : filterValues?.[0],
-                debounceMs: flags['debounce-ms'],
-                maxPerHour: flags['max-per-hour'],
-            });
-            const stochastic = {};
-            (0, triggers_1.setDefined)(stochastic, {
-                probability: flags.probability === undefined ? undefined : Number(flags.probability),
-                jitterMs: flags['jitter-ms'],
-                maxFiresPerDay: flags['max-fires-per-day'],
-                evalIntervalMinutes: flags['eval-interval-minutes'],
-            });
+            Object.assign(event, (0, triggers_1.buildEventConfigFromFlags)(flags, filterValues));
+            const stochastic = (0, triggers_1.buildStochasticConfigFromFlags)(flags);
             const selfScheduled = (0, triggers_1.buildSelfScheduledConfigFromFlags)(flags);
             const form = (0, triggers_1.buildFormConfigFromFlags)(flags);
             const chatMessage = (0, triggers_1.buildChatMessageConfigFromFlags)(flags);