@skrr-ai/cli 0.1.19 → 0.1.20

package/dist/commands/tasks/complete.d.ts

@@ -6,12 +6,19 @@ type CompletionStatus = 'completed' | 'failed';
 type TaskCommentResult = Awaited<ReturnType<typeof dataService.addTaskComment>>;
 type MovedTaskResult = Awaited<ReturnType<typeof dataService.moveTask>>;
 /** Wire shape of POST /api/tasks/:taskId/complete (OSK-1969). */
+/** One thing a completion did not have. Never a refusal — `done` has none. */
+export interface CompletionAdvisory {
+    code: string;
+    message: string;
+}
 export interface CompleteEndpointResponse {
     task: MovedTaskResult | null;
     comment: TaskCommentResult | null;
     commentFailed?: boolean;
-    deliveryHeld?: boolean;
-    deliveryReason?: string;
+    /** What the completion was missing. `done` has no preconditions, so every
+     *  condition that used to refuse one now travels with it instead. The task
+     *  reached the requested terminal state regardless. */
+    advisories?: CompletionAdvisory[];
 }
 export interface CompleteTransport {
     /** POST /api/tasks/:taskId/complete — atomic move + TASK_OUTPUT comment. */
@@ -35,8 +42,7 @@ export interface DurableCompletionResult {
     movedTask: MovedTaskResult | null;
     moved: boolean;
     commentFailed: boolean;
-    deliveryHeld?: boolean;
-    deliveryReason?: string;
+    advisories?: CompletionAdvisory[];
     /** true when the atomic /complete endpoint handled the finalization. */
     usedAtomicEndpoint: boolean;
 }

package/dist/commands/tasks/complete.js

@@ -194,8 +194,7 @@ async function completeTaskDurably(opts) {
             movedTask: response.task ?? null,
             moved: true,
             commentFailed: response.commentFailed === true,
-            ...(response.deliveryHeld ? { deliveryHeld: true } : {}),
-            ...(response.deliveryReason ? { deliveryReason: response.deliveryReason } : {}),
+            ...(response.advisories?.length ? { advisories: response.advisories } : {}),
             usedAtomicEndpoint: true,
         };
     }
@@ -611,7 +610,7 @@ class TasksComplete extends base_command_1.BaseCommand {
                 ...(report ? { report } : {}),
                 body,
             },
-            ...(result.deliveryHeld ? { deliveryHeld: true, deliveryReason: result.deliveryReason } : {}),
+            ...(result.advisories?.length ? { advisories: result.advisories } : {}),
         };
         if (flags.json) {
             const url = movedTask
@@ -634,8 +633,11 @@ class TasksComplete extends base_command_1.BaseCommand {
                 ? `Task ${completedTaskId} was already ${newStatus}; the outcome was amended.`
                 : `Moved task ${completedTaskId} to ${newStatus}`);
         }
-        if (result.deliveryHeld) {
-            this.warn('Delivery is not verified on the default branch; the task was held at in_review instead of done.');
+        for (const advisory of result.advisories ?? []) {
+            // One warn per unmet condition. Each already reads as an observation —
+            // the completion happened — so the CLI relays them rather than
+            // re-wording them into something that sounds like a failure.
+            this.warn(advisory.message);
         }
         if (report) {
             const url = (0, web_url_1.taskUrlFrom)(this.cliConfig.baseURL, movedTask ?? { id: completedTaskId });

package/dist/commands/tasks/self-schedule.d.ts

@@ -0,0 +1,30 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * `skrr tasks self-schedule` — park a task for a self-initiated return.
+ *
+ * Distinct from `skrr tasks schedule`, and the distinction is the point.
+ * `schedule` writes the AUTHOR's calendar (`scheduledFor` + `recurrence`), the
+ * thing the scheduler consumes and re-arms and every calendar surface renders.
+ * This writes a separate `self_scheduled` trigger row, so an agent working the
+ * task can say "come back in two hours" without editing the human's Monday-9am
+ * recurrence to mean something the human never asked for.
+ *
+ * Both can be set at once. Neither erases the other.
+ */
+export default class TasksSelfSchedule extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        at: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        in: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        note: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'max-per-day': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        show: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        clear: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tasks/self-schedule.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const task_extras_1 = require("../../lib/task-extras");
+/**
+ * `skrr tasks self-schedule` — park a task for a self-initiated return.
+ *
+ * Distinct from `skrr tasks schedule`, and the distinction is the point.
+ * `schedule` writes the AUTHOR's calendar (`scheduledFor` + `recurrence`), the
+ * thing the scheduler consumes and re-arms and every calendar surface renders.
+ * This writes a separate `self_scheduled` trigger row, so an agent working the
+ * task can say "come back in two hours" without editing the human's Monday-9am
+ * recurrence to mean something the human never asked for.
+ *
+ * Both can be set at once. Neither erases the other.
+ */
+class TasksSelfSchedule extends base_command_1.BaseCommand {
+    static description = "Park a task for a self-initiated return — separate from the author's schedule";
+    static examples = [
+        '<%= config.bin %> tasks self-schedule <task-id> --in 2h --note "check whether the deploy settled"',
+        '<%= config.bin %> tasks self-schedule <task-id> --at 2026-09-09T14:00:00Z',
+        '<%= config.bin %> tasks self-schedule <task-id> --show',
+        '<%= config.bin %> tasks self-schedule <task-id> --clear',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Task ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+        at: core_1.Flags.string({ description: 'Absolute return time (ISO-8601 UTC)' }),
+        in: core_1.Flags.string({ description: 'Relative return time such as 90m, 2h, 3d' }),
+        note: core_1.Flags.string({
+            // Was "handed to the agent as the return prompt", which is not true:
+            // `task_execute` builds the run's prompt from the Task, so this string is
+            // recorded and never read by the run. See `TaskScheduler/selfSchedule.js`.
+            description: 'Why you are coming back — recorded on the return for you to read back',
+        }),
+        'max-per-day': core_1.Flags.integer({
+            description: 'Cap on self-initiated returns per day (1-24, default 4)',
+        }),
+        show: core_1.Flags.boolean({ description: 'Print the pending return without changing it' }),
+        clear: core_1.Flags.boolean({ description: 'Cancel the pending return' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(TasksSelfSchedule);
+        if (flags.show && flags.clear) {
+            this.error('Pass at most one of --show or --clear.', { exit: 1 });
+        }
+        let result;
+        try {
+            if (flags.show) {
+                result = await task_extras_1.taskSelfScheduleApi.get(args.id);
+            }
+            else if (flags.clear) {
+                result = await task_extras_1.taskSelfScheduleApi.clear(args.id);
+            }
+            else {
+                const runAt = resolveRunAt(flags.at, flags.in);
+                if (!runAt) {
+                    this.error('Pass --at <ISO-8601>, --in <duration>, or one of --show / --clear.', {
+                        exit: 1,
+                    });
+                }
+                result = await task_extras_1.taskSelfScheduleApi.park(args.id, {
+                    runAt,
+                    ...(flags.note ? { note: flags.note } : {}),
+                    ...(flags['max-per-day'] ? { maxFiresPerDay: flags['max-per-day'] } : {}),
+                });
+            }
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result ?? {}, null, 2));
+            return;
+        }
+        const runAt = result?.runAt;
+        if (!runAt) {
+            this.log(`Task ${args.id} has no pending return.`);
+            return;
+        }
+        // `pending` is derived server-side: a return that has already fired keeps
+        // its instant on the row, and printing that verbatim would report a return
+        // as upcoming an hour after it happened.
+        const spent = result?.pending === false;
+        this.log(`Task ${args.id} ${spent ? 'last returned at' : 'returns at'} ${runAt}`);
+        if (result?.note)
+            this.log(`Note: ${result.note}`);
+        if (!spent && result?.maxFiresPerDay) {
+            this.log(`Cap: ${result.maxFiresPerDay} self-initiated returns/day`);
+        }
+    }
+}
+exports.default = TasksSelfSchedule;
+/** `90m` / `2h` / `3d`, or an absolute instant. Absolute wins when both are given. */
+function resolveRunAt(at, relative) {
+    if (at)
+        return at;
+    if (!relative)
+        return undefined;
+    const match = /^(\d+)\s*(m|min|mins|h|hr|hrs|d)$/i.exec(relative.trim());
+    if (!match)
+        return undefined;
+    const value = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const MS_PER_UNIT = { m: 60_000, h: 3_600_000, d: 86_400_000 };
+    // `min`/`mins`/`hr`/`hrs` collapse onto their first character, which is
+    // unambiguous across the three units this accepts.
+    const ms = value * (MS_PER_UNIT[unit[0]] ?? MS_PER_UNIT.h);
+    return new Date(Date.now() + ms).toISOString();
+}

package/dist/commands/triggers/disable.js

@@ -26,7 +26,9 @@ class TriggersDisable extends base_command_1.BaseCommand {
             return;
         }
         this.log('Disabled trigger:');
-        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line));
+        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line), {
+            baseURL: this.cliConfig.baseURL,
+        });
     }
 }
 exports.default = TriggersDisable;

package/dist/commands/triggers/enable.js

@@ -26,7 +26,9 @@ class TriggersEnable extends base_command_1.BaseCommand {
             return;
         }
         this.log('Enabled trigger:');
-        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line));
+        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line), {
+            baseURL: this.cliConfig.baseURL,
+        });
     }
 }
 exports.default = TriggersEnable;

package/dist/commands/triggers/rotate-secret.js

@@ -30,6 +30,11 @@ class TriggersRotateSecret extends base_command_1.BaseCommand {
             return;
         }
         this.log(`Secret: ${String(result.secret ?? '-')}`);
+        // The secret alone does not let anyone call in. This command was the natural
+        // place to learn the endpoint and printed everything except it, so building
+        // the integration meant reading the API source or guessing the path.
+        this.log(`URL:    POST ${(0, triggers_1.webhookIngestUrl)(this.cliConfig.baseURL, args.id)}`);
+        this.log('Sign with header x-trigger-signature; send x-trigger-timestamp alongside it.');
         this.log(String(result.note ?? 'Save this secret now; it cannot be retrieved later.'));
         if (result.lastRotatedAt)
             this.log(`Rotated at: ${String(result.lastRotatedAt)}`);

package/dist/commands/triggers/show.js

@@ -29,7 +29,9 @@ class TriggersShow extends base_command_1.BaseCommand {
             this.log(JSON.stringify(trigger, null, 2));
             return;
         }
-        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line));
+        (0, triggers_1.renderTriggerSummary)(trigger, (line) => this.log(line), {
+            baseURL: this.cliConfig.baseURL,
+        });
     }
 }
 exports.default = TriggersShow;

package/dist/lib/commitments.d.ts

@@ -260,6 +260,16 @@ export declare const commitmentApi: {
         object: "commitment_action_proposal_list";
         data: CommitmentActionProposal[];
     }>;
+    /**
+     * Propose a prepared action for a check.
+     *
+     * The half that was missing. `decide` and `execute` were both reachable, so a
+     * headless operator could only ever REACT to proposals the server made — an
+     * asymmetry that leaves the domain half-usable in exactly the way the parity
+     * rule exists to catch. A locally-running agent that has investigated a
+     * commitment and knows what should be done had no way to say so.
+     */
+    proposeActionProposal: (id: string, body: Record<string, unknown>) => Promise<Record<string, unknown>>;
     decideActionProposal: (id: string, proposalId: string, decision: "approve" | "reject") => Promise<Record<string, unknown>>;
     executeActionProposal: (id: string, proposalId: string) => Promise<Record<string, unknown>>;
     preflight: (id: string, nextRunCount?: number) => Promise<CommitmentPreflightReport>;
@@ -410,6 +420,13 @@ export declare function readCommitmentAgentDirective({ directive, file, }: {
  * active or terminal state, but importing it must still create a draft.
  */
 export declare function normalizeCreateBody(input: Record<string, unknown>): Record<string, unknown>;
+export declare function parseCommitmentConcurrencyLimit(input: string | undefined): number | null | undefined;
+export declare function commitmentConcurrencyEnvelopePatch({ rawValue, reason, autonomous, }: {
+    rawValue?: string;
+    reason?: string;
+    autonomous?: boolean;
+}): Record<string, unknown> | undefined;
+export declare function describeCommitmentConcurrency(commitment: CommitmentView): string;
 export declare function parseIntervalToMs(input: string): number;
 /**
  * Assemble the `watchedSources` array from CLI flags — one place, so `create`

package/dist/lib/commitments.js

@@ -6,6 +6,9 @@ exports.authoringAutonomyModeForStored = authoringAutonomyModeForStored;
 exports.commitmentAutonomyLabel = commitmentAutonomyLabel;
 exports.readCommitmentAgentDirective = readCommitmentAgentDirective;
 exports.normalizeCreateBody = normalizeCreateBody;
+exports.parseCommitmentConcurrencyLimit = parseCommitmentConcurrencyLimit;
+exports.commitmentConcurrencyEnvelopePatch = commitmentConcurrencyEnvelopePatch;
+exports.describeCommitmentConcurrency = describeCommitmentConcurrency;
 exports.parseIntervalToMs = parseIntervalToMs;
 exports.buildWatchedSources = buildWatchedSources;
 exports.describeEvidenceHealth = describeEvidenceHealth;
@@ -153,6 +156,16 @@ exports.commitmentApi = {
     checks: (id, limit) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/checks`, { limit })),
     actionHistory: (id, limit) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/action-history`, { limit })),
     actionProposals: (id, query = {}) => data_provider_1.request.get((0, triggers_1.withQuery)(`${base(id)}/action-proposals`, query)),
+    /**
+     * Propose a prepared action for a check.
+     *
+     * The half that was missing. `decide` and `execute` were both reachable, so a
+     * headless operator could only ever REACT to proposals the server made — an
+     * asymmetry that leaves the domain half-usable in exactly the way the parity
+     * rule exists to catch. A locally-running agent that has investigated a
+     * commitment and knows what should be done had no way to say so.
+     */
+    proposeActionProposal: (id, body) => data_provider_1.request.post(`${base(id)}/action-proposals`, body),
     decideActionProposal: (id, proposalId, decision) => data_provider_1.request.post(`${base(id)}/action-proposals/${encodeURIComponent(proposalId)}/decision`, {
         decision,
     }),
@@ -321,6 +334,51 @@ function normalizeCreateBody(input) {
     }
     return out;
 }
+function parseCommitmentConcurrencyLimit(input) {
+    if (input === undefined)
+        return undefined;
+    const raw = String(input).trim().toLowerCase();
+    if (['unlimited', 'unbounded', 'none', 'null'].includes(raw))
+        return null;
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < 1 || value > 100) {
+        throw new Error('--max-concurrent-runs must be "unlimited" or an integer from 1 to 100.');
+    }
+    return value;
+}
+function commitmentConcurrencyEnvelopePatch({ rawValue, reason, autonomous = process.env.OVERSKY_AUTONOMOUS_SESSION === '1', }) {
+    const value = parseCommitmentConcurrencyLimit(rawValue);
+    const normalizedReason = reason?.trim();
+    if (value === undefined) {
+        if (normalizedReason) {
+            throw new Error('--concurrency-reason requires --max-concurrent-runs.');
+        }
+        return undefined;
+    }
+    if (autonomous && value !== null) {
+        throw new Error('An autonomous Agent may suggest a finite Commitment concurrency cap, but cannot activate owner policy. Omit the field or use unlimited; an owner can set the cap later.');
+    }
+    if (value !== null && !normalizedReason) {
+        throw new Error('A finite --max-concurrent-runs value requires --concurrency-reason.');
+    }
+    return {
+        maxConcurrentRuns: value,
+        ...(normalizedReason ? { maxConcurrentRunsReason: normalizedReason } : {}),
+    };
+}
+function describeCommitmentConcurrency(commitment) {
+    const envelope = commitment.policy?.autonomyEnvelope;
+    const limit = envelope?.maxConcurrentRuns;
+    const decision = envelope?.maxConcurrentRunsDecision;
+    if (limit == null) {
+        const source = decision?.mode === 'unlimited' ? decision.source : 'default';
+        return `unlimited (${source})`;
+    }
+    const authority = decision?.authority || 'unknown';
+    const source = decision?.source || 'legacy';
+    const review = authority === 'unknown' ? ' — review required' : '';
+    return `${limit} (${authority}/${source}${review})`;
+}
 /**
  * Parse a human interval ("15m", "6h", "1d", or a bare number of minutes) into
  * milliseconds. Throws on unparseable input, on trailing junk, and on values
@@ -672,6 +730,7 @@ latestCheck) {
         log(`Next check:${` ${commitment.cadence.nextCheckAt}`}`);
     log(`Mode:      ${describeAutonomyLine(commitment, latestCheck)}`);
     log(`Delivery:  ${(0, commitment_product_1.deliveryLabel)(commitment.delivery?.mode)}${commitment.delivery?.repo ? ` · ${commitment.delivery.repo}` : ''}${commitment.delivery?.baseBranch ? ` → ${commitment.delivery.baseBranch}` : ''}`);
+    log(`Concurrency: ${describeCommitmentConcurrency(commitment)}`);
     const criteria = commitment.target?.successCriteria || [];
     const evidenceHealth = latestCheck?.inputs?.evidenceHealth;
     const evidenceLine = describeEvidenceHealth(evidenceHealth, criteria.length);

package/dist/lib/node-adapter.js

@@ -79,6 +79,10 @@ function createNodeAdapter(opts = {}) {
         const { token } = currentCredential();
         const headers = {
             Accept: 'application/json',
+            // Server-side authoring provenance. This is attribution, not authority;
+            // owner/admin decisions are still authenticated and validated at the
+            // route boundary.
+            'X-Skrr-Client': 'cli',
             ...(extra ?? {}),
         };
         if (token) {

package/dist/lib/task-extras.d.ts

@@ -32,6 +32,24 @@ export declare const taskLookupApi: {
     treePosition: (id: string, body: Json) => Promise<Json>;
     createAndStart: (body: Json) => Promise<Json>;
 };
+/**
+ * Self-schedule — "come back to this task at T", owned by whoever is working it.
+ *
+ * A different resource from `/schedule`, not a variant of it. `/schedule` writes
+ * `Task.scheduledFor` + `recurrence` (the author's calendar, which the scheduler
+ * consumes and re-arms); this writes a `kind:'self_scheduled'` trigger row. Both
+ * can be set on one task and neither erases the other, so a headless agent can
+ * defer itself without editing the human's recurrence to mean something the
+ * human never asked for.
+ *
+ * PUT, not POST: a task has at most one pending return and parking again
+ * replaces it.
+ */
+export declare const taskSelfScheduleApi: {
+    get: (id: string) => Promise<Json>;
+    park: (id: string, body: Json) => Promise<Json>;
+    clear: (id: string) => Promise<Json>;
+};
 /**
  * The completion URL as a STRING.
  *

package/dist/lib/task-extras.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.taskChatApi = exports.taskLookupApi = exports.taskWorkflowApi = void 0;
+exports.taskChatApi = exports.taskSelfScheduleApi = exports.taskLookupApi = exports.taskWorkflowApi = void 0;
 exports.taskCompletePath = taskCompletePath;
 /**
  * task-extras.ts — the `/api/tasks` endpoints that have no `dataService.*`
@@ -51,6 +51,24 @@ exports.taskLookupApi = {
     treePosition: (id, body) => data_provider_1.request.patch(`${base(id)}/tree-position`, body),
     createAndStart: (body) => data_provider_1.request.post(`${MOUNT}/create-and-start`, body),
 };
+/**
+ * Self-schedule — "come back to this task at T", owned by whoever is working it.
+ *
+ * A different resource from `/schedule`, not a variant of it. `/schedule` writes
+ * `Task.scheduledFor` + `recurrence` (the author's calendar, which the scheduler
+ * consumes and re-arms); this writes a `kind:'self_scheduled'` trigger row. Both
+ * can be set on one task and neither erases the other, so a headless agent can
+ * defer itself without editing the human's recurrence to mean something the
+ * human never asked for.
+ *
+ * PUT, not POST: a task has at most one pending return and parking again
+ * replaces it.
+ */
+exports.taskSelfScheduleApi = {
+    get: (id) => data_provider_1.request.get(`${base(id)}/self-schedule`),
+    park: (id, body) => data_provider_1.request.put(`${base(id)}/self-schedule`, body),
+    clear: (id) => data_provider_1.request.delete(`${base(id)}/self-schedule`),
+};
 /**
  * The completion URL as a STRING.
  *

package/dist/lib/triggers.d.ts

@@ -18,7 +18,7 @@ export declare const TRIGGER_SCOPE_KINDS: readonly ["agent", "group_chat_subscri
  * capability was live and unreachable. `watch_until` and `sensor_poll` had been
  * in that state for longer.
  */
-export declare const TRIGGER_EXECUTOR_MODES: readonly ["send_message", "run_only", "enqueue_group_chat_agent_turn", "enqueue_assistant_turn", "enqueue_space_assistant_turn", "proactive_orchestrator_check", "auto_dream_orchestrator", "task_schedule_fire", "goal_planner_tick", "morning_briefing", "builtin_action", "watch_until", "sensor_poll", "external_work_task", "notify_user", "space_cycle_rollover"];
+export declare const TRIGGER_EXECUTOR_MODES: readonly ["send_message", "run_only", "enqueue_group_chat_agent_turn", "enqueue_assistant_turn", "enqueue_space_assistant_turn", "proactive_orchestrator_check", "auto_dream_orchestrator", "task_schedule_fire", "goal_planner_tick", "morning_briefing", "builtin_action", "task_execute", "watch_until", "sensor_poll", "external_work_task", "notify_user", "space_cycle_rollover"];
 export declare const TRIGGER_EVENT_FILTER_MODES: readonly ["equals", "contains", "in_set"];
 export declare const TRIGGER_CONCURRENCY_POLICIES: readonly ["coalesce_if_active", "allow_parallel"];
 export declare const TRIGGER_FORM_RESPONSE_MODES: readonly ["thank_you_page", "redirect_url", "run_complete"];
@@ -95,6 +95,16 @@ export interface TriggerDefinition {
     chatMessage?: Record<string, unknown>;
     audit?: Record<string, unknown>;
     webhook?: Record<string, unknown>;
+    /**
+     * Server-DERIVED: maintained by a managed producer, so the mutation routes
+     * refuse to edit or remove it. Optional because a server predating the field
+     * omits it, which correctly reads as "not producer-owned".
+     *
+     * Declared here rather than inferred, and never re-derived from an id prefix
+     * or an execution mode — the route owns that policy and a local copy is free
+     * to disagree with the route that does the refusing.
+     */
+    producerOwned?: boolean;
     createdAt?: string;
     updatedAt?: string;
 }
@@ -327,7 +337,16 @@ export declare function armedStateLabel(enabled: boolean | undefined): string;
  * parentheses for scripts.
  */
 export declare function writeModeLabel(writeMode: string): string;
-export declare function renderTriggerSummary(trigger: TriggerDefinition, log: (line: string) => void): void;
+/**
+ * Where an external caller POSTs to fire this trigger.
+ *
+ * Same origin as every other `/api/...` call the CLI makes, so it is built from
+ * the configured base URL rather than guessed.
+ */
+export declare function webhookIngestUrl(baseURL: string, triggerId: string): string;
+export declare function renderTriggerSummary(trigger: TriggerDefinition, log: (line: string) => void, options?: {
+    baseURL?: string;
+}): void;
 export declare function renderLegacyRuns(runs: LegacyTriggerRun[], log: (line: string) => void): void;
 export declare function renderFireAudit(fires: TriggerFireRecord[], log: (line: string) => void): void;
 /**

package/dist/lib/triggers.js

@@ -32,6 +32,7 @@ exports.renderTriggerList = renderTriggerList;
 exports.formatDuplicateSubscriptionWarning = formatDuplicateSubscriptionWarning;
 exports.armedStateLabel = armedStateLabel;
 exports.writeModeLabel = writeModeLabel;
+exports.webhookIngestUrl = webhookIngestUrl;
 exports.renderTriggerSummary = renderTriggerSummary;
 exports.renderLegacyRuns = renderLegacyRuns;
 exports.renderFireAudit = renderFireAudit;
@@ -86,6 +87,11 @@ exports.TRIGGER_EXECUTOR_MODES = [
     'goal_planner_tick',
     'morning_briefing',
     'builtin_action',
+    // The author-visible way to run a Task from a trigger. Its internal sibling
+    // `task_schedule_fire` sits two lines up and the server refuses it from any
+    // non-managed caller, so without this entry a headless operator could author
+    // every kind of task watcher except one that does the task.
+    'task_execute',
     // User-authorable capabilities the server allows on the agent scope.
     'watch_until',
     'sensor_poll',
@@ -784,11 +790,40 @@ function writeModeLabel(writeMode) {
             return writeMode;
     }
 }
-function renderTriggerSummary(trigger, log) {
+/**
+ * Kinds that expose a signed inbound HTTP channel. Mirrors `WEBHOOK_KINDS` in
+ * `api/server/routes/triggers.js`, which is what actually decides — this copy
+ * only chooses whether to PRINT a URL, so being behind costs a missing hint
+ * rather than a wrong answer.
+ */
+const WEBHOOK_INGEST_KINDS = new Set(['on_demand', 'form', 'chat_message']);
+/**
+ * Where an external caller POSTs to fire this trigger.
+ *
+ * Same origin as every other `/api/...` call the CLI makes, so it is built from
+ * the configured base URL rather than guessed.
+ */
+function webhookIngestUrl(baseURL, triggerId) {
+    return `${String(baseURL).replace(/\/+$/, '')}/api/triggers/webhook/${encodeURIComponent(triggerId)}`;
+}
+function renderTriggerSummary(trigger, log, options = {}) {
     log(`ID:       ${trigger.id ?? '-'}`);
     log(`Kind:     ${trigger.kind ?? '-'}`);
     log(`Armed:    ${armedStateLabel(trigger.enabled)}`);
     log(`Scope:    ${scopeLabel(trigger)}`);
+    /*
+     * Say when the row is not yours to change.
+     *
+     * `producerOwned` is derived by the server and reported on every trigger read.
+     * Without it a headless operator reads `skrr triggers show task-schedule:<id>`,
+     * sees an ordinary-looking trigger, runs `triggers delete`, and learns from a
+     * 409 — for a row that was never editable. Same argument the `Contract:` /
+     * `Writes:` lines below were added under: a trigger with a property this
+     * consequential should state it at the moment it is read.
+     */
+    if (trigger.producerOwned === true) {
+        log('Managed:  by the platform — not editable here; change the object that owns it');
+    }
     if (trigger.label)
         log(`Label:    ${trigger.label}`);
     if (trigger.execution?.mode)
@@ -809,6 +844,18 @@ function renderTriggerSummary(trigger, log) {
     if (trigger.webhook?.configured !== undefined) {
         log(`Webhook:  ${trigger.webhook.configured ? 'configured' : 'not configured'}`);
     }
+    /*
+     * The endpoint, not just "configured".
+     *
+     * An `on_demand` trigger exists so something outside the platform can fire it,
+     * and the CLI could report that a secret was set while never saying where to
+     * send it — the one fact the integration cannot be built without. Printed for
+     * every webhook-bearing kind, whether or not a secret has been minted yet, so
+     * "what is my URL" never requires a rotate.
+     */
+    if (options.baseURL && trigger.id && WEBHOOK_INGEST_KINDS.has(String(trigger.kind))) {
+        log(`Webhook URL: POST ${webhookIngestUrl(options.baseURL, trigger.id)}`);
+    }
 }
 function renderLegacyRuns(runs, log) {
     if (runs.length === 0) {