@stigmer/protos 3.5.3 → 3.7.0

package/ai/stigmer/agentic/schedule/v1/command_connect.d.ts

@@ -0,0 +1,189 @@
+/**
+ * ScheduleCommandController handles write operations for schedules.
+ *
+ * @generated from service ai.stigmer.agentic.schedule.v1.ScheduleCommandController
+ */
+export declare const ScheduleCommandController: {
+    readonly typeName: "ai.stigmer.agentic.schedule.v1.ScheduleCommandController";
+    readonly methods: {
+        /**
+         * Create or update a schedule.
+         *
+         * @internal
+         * The authorization and state-operation are determined depending on
+         * whether the schedule is going to be created or updated, resolved as
+         * part of request execution. Status is preserved verbatim across
+         * apply-as-update (the AgentChannel decision-004 posture): status is
+         * written only by the scheduling runtime and by the explicit resume
+         * command, and a routine manifest apply must never reset the failure
+         * streak or un-pause a platform-paused schedule (DD-008 D7 / DD-009
+         * pinned behaviors / DD-013 D-D).
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.apply
+         */
+        readonly apply: {
+            readonly name: "apply";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Create a schedule.
+         *
+         * Scheduling an agent is a billing-affecting decision: every fire
+         * creates an execution that consumes the schedule-owning
+         * organization's credits, unattended.
+         *
+         * @internal
+         * Authorization: requires can_edit on the REFERENCED AGENT
+         * (spec.agent.agent_ref), checked in-handler — the AgentChannel /
+         * same-org AgentShare Phase A bar (DD-009 C-6): whoever may edit the
+         * agent may schedule it; there is deliberately no org-level
+         * can_create_schedule permission. Standard org-scoped create tuples
+         * (owner = creator); no visibility tuples (the kind has no visibility
+         * block). Invariant enforced here: metadata.org must equal
+         * spec.agent.agent_ref.org.
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.create
+         */
+        readonly create: {
+            readonly name: "create";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Update an existing schedule.
+         *
+         * Replaces the spec wholesale. The slug, the referenced agent, and the
+         * target arm are immutable; cron, time zone, enablement, and the
+         * message may all change. Status (firing observations, the platform
+         * pause) is never touched by updates — use resume to clear a platform
+         * pause.
+         *
+         * @internal
+         * Authorization: requires can_edit permission on the schedule.
+         * agent_ref immutability is a consent-bar guarantee, not convenience
+         * (DD-009 C-7): create's bar is can_edit on the REFERENCED agent, and
+         * a repointing update would let a schedule owner drive an agent they
+         * may not edit — the AgentChannel rule for the AgentChannel reason.
+         * Target-arm immutability (an agent schedule cannot become a workflow
+         * schedule once that arm exists) is enforced in-handler: the two
+         * targets enter different execution pipelines. Update deliberately
+         * does NOT clear a platform auto-pause (DD-013 D-D, superseding the
+         * DD-008 D7 ensure-on-mutate sketch): apply routes through this same
+         * handler, so any update-clears-pause behavior would let a routine
+         * GitOps re-apply silently un-pause a failing schedule. resume is the
+         * one clearing path.
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.update
+         */
+        readonly update: {
+            readonly name: "update";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Delete a schedule.
+         *
+         * Firing stops permanently. Executions created by past fires are
+         * untouched. To stop firing while keeping the schedule and its
+         * history, disable it (enabled=false) instead.
+         *
+         * @internal
+         * Authorization: requires can_delete permission on the schedule. The
+         * referenced agent is untouched. The Temporal artifact teardown
+         * (best-effort, AFTER the row delete — DD-008 D9) arrives with the
+         * clock; until then delete is the row alone, and an orphaned artifact
+         * is harmless by construction (fire-time revalidation no-ops it).
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.delete
+         */
+        readonly delete: {
+            readonly name: "delete";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Resume a schedule the platform paused after repeated run failures.
+         *
+         * Clears status.paused_reason, resets status.consecutive_failures,
+         * and re-arms the clock. Resuming a schedule that is not paused
+         * succeeds and changes nothing. A disabled schedule stays disabled:
+         * resume clears the platform's pause, not the owner's switch
+         * (spec.enabled).
+         *
+         * @internal
+         * Authorization: requires can_edit permission on the schedule — the
+         * update bar; resuming does not change which agent runs, so it does
+         * not re-open create's consent bar (DD-009 C-6). This command is
+         * deliberately the ONLY path that clears a platform auto-pause
+         * (DD-013 D-D): apply and update preserve status byte-for-byte, so a
+         * routine manifest apply can never silently un-pause a failing
+         * schedule. The cloud handler loads before authorizing (#224: a
+         * missing schedule answers NOT_FOUND, not PERMISSION_DENIED) and
+         * patches status leaves rather than saving the row — the tick is a
+         * concurrent status writer. OSS excludes the authorization step, per
+         * its recorded single-user posture.
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.resume
+         */
+        readonly resume: {
+            readonly name: "resume";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Trigger a schedule to fire once, immediately, and answer with the
+         * run's real outcome.
+         *
+         * The manual fire runs synchronously through the standard execution
+         * create pipeline — every launch gate runs — and the result names what
+         * happened: the created execution's id, or the refusing gate's own
+         * copy verbatim. status.last_fire_at and status.last_execution_id
+         * record a started run. Manual fires do NOT feed the failure streak —
+         * the streak is the unattended (cron) health signal, and a test fire
+         * of a broken schedule must not race its owner to the pause threshold.
+         *
+         * A disabled schedule refuses (enable it first). A platform-paused
+         * schedule MAY be triggered — a test fire is exactly how an owner
+         * verifies a fix before resuming; resume remains the one path that
+         * clears the pause.
+         *
+         * @internal
+         * Authorization: requires can_edit permission on the schedule — the
+         * update bar (DD-014 D-A). Project DD-017 D-5/D-6 amends DD-014: the
+         * artifact round-trip is gone for manual fires (it made the fire
+         * asynchronous, so the RPC answered before the launch gates ran — a
+         * false "run started" beside a climbing failure counter). Cron fires
+         * keep the tracked artifact tick unchanged. The disabled refusal
+         * SURVIVES for a different reason than DD-014 D-B recorded:
+         * ScheduleBlueprintAccess requires spec.enabled at the create gate AND
+         * the mid-run sandbox read predicate, so a disabled-schedule run would
+         * die mid-execution after billing side effects (consoles offer
+         * "Enable & run now" instead; the fire-legitimacy model that would
+         * lift this is DD-017's named follow-up). Two-level contract: a gRPC
+         * error means the trigger itself was refused (disabled →
+         * FAILED_PRECONDITION with the byte-pinned copy, missing → NOT_FOUND
+         * before authorize, #224); a gRPC success means the fire happened and
+         * ScheduleTriggerResult names the run's outcome — a deterministically
+         * refused run is a successful trigger honestly reported, never an
+         * exception. The handler stamps last_fire_at/last_execution_id and
+         * writes the fire-ledger row (origin=manual) because the tick is not
+         * in the path to do it; status writes ride updateFields, never save()
+         * (DD-010 D-B). OSS mirrors the semantics; it excludes the
+         * authorization step per its recorded single-user posture.
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.trigger
+         */
+        readonly trigger: {
+            readonly name: "trigger";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+    };
+};

package/ai/stigmer/agentic/schedule/v1/command_connect.js

@@ -0,0 +1,197 @@
+// @generated by protoc-gen-connect-es v1.6.1 with parameter "target=ts,import_extension=js"
+// @generated from file ai/stigmer/agentic/schedule/v1/command.proto (package ai.stigmer.agentic.schedule.v1, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+import { Schedule } from "./api_pbjs";
+import { MethodKind } from "@bufbuild/protobuf";
+import { ScheduleId, ScheduleTriggerResult } from "./io_pbjs";
+/**
+ * ScheduleCommandController handles write operations for schedules.
+ *
+ * @generated from service ai.stigmer.agentic.schedule.v1.ScheduleCommandController
+ */
+export const ScheduleCommandController = {
+    typeName: "ai.stigmer.agentic.schedule.v1.ScheduleCommandController",
+    methods: {
+        /**
+         * Create or update a schedule.
+         *
+         * @internal
+         * The authorization and state-operation are determined depending on
+         * whether the schedule is going to be created or updated, resolved as
+         * part of request execution. Status is preserved verbatim across
+         * apply-as-update (the AgentChannel decision-004 posture): status is
+         * written only by the scheduling runtime and by the explicit resume
+         * command, and a routine manifest apply must never reset the failure
+         * streak or un-pause a platform-paused schedule (DD-008 D7 / DD-009
+         * pinned behaviors / DD-013 D-D).
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.apply
+         */
+        apply: {
+            name: "apply",
+            I: Schedule,
+            O: Schedule,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Create a schedule.
+         *
+         * Scheduling an agent is a billing-affecting decision: every fire
+         * creates an execution that consumes the schedule-owning
+         * organization's credits, unattended.
+         *
+         * @internal
+         * Authorization: requires can_edit on the REFERENCED AGENT
+         * (spec.agent.agent_ref), checked in-handler — the AgentChannel /
+         * same-org AgentShare Phase A bar (DD-009 C-6): whoever may edit the
+         * agent may schedule it; there is deliberately no org-level
+         * can_create_schedule permission. Standard org-scoped create tuples
+         * (owner = creator); no visibility tuples (the kind has no visibility
+         * block). Invariant enforced here: metadata.org must equal
+         * spec.agent.agent_ref.org.
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.create
+         */
+        create: {
+            name: "create",
+            I: Schedule,
+            O: Schedule,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Update an existing schedule.
+         *
+         * Replaces the spec wholesale. The slug, the referenced agent, and the
+         * target arm are immutable; cron, time zone, enablement, and the
+         * message may all change. Status (firing observations, the platform
+         * pause) is never touched by updates — use resume to clear a platform
+         * pause.
+         *
+         * @internal
+         * Authorization: requires can_edit permission on the schedule.
+         * agent_ref immutability is a consent-bar guarantee, not convenience
+         * (DD-009 C-7): create's bar is can_edit on the REFERENCED agent, and
+         * a repointing update would let a schedule owner drive an agent they
+         * may not edit — the AgentChannel rule for the AgentChannel reason.
+         * Target-arm immutability (an agent schedule cannot become a workflow
+         * schedule once that arm exists) is enforced in-handler: the two
+         * targets enter different execution pipelines. Update deliberately
+         * does NOT clear a platform auto-pause (DD-013 D-D, superseding the
+         * DD-008 D7 ensure-on-mutate sketch): apply routes through this same
+         * handler, so any update-clears-pause behavior would let a routine
+         * GitOps re-apply silently un-pause a failing schedule. resume is the
+         * one clearing path.
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.update
+         */
+        update: {
+            name: "update",
+            I: Schedule,
+            O: Schedule,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Delete a schedule.
+         *
+         * Firing stops permanently. Executions created by past fires are
+         * untouched. To stop firing while keeping the schedule and its
+         * history, disable it (enabled=false) instead.
+         *
+         * @internal
+         * Authorization: requires can_delete permission on the schedule. The
+         * referenced agent is untouched. The Temporal artifact teardown
+         * (best-effort, AFTER the row delete — DD-008 D9) arrives with the
+         * clock; until then delete is the row alone, and an orphaned artifact
+         * is harmless by construction (fire-time revalidation no-ops it).
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.delete
+         */
+        delete: {
+            name: "delete",
+            I: ScheduleId,
+            O: Schedule,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Resume a schedule the platform paused after repeated run failures.
+         *
+         * Clears status.paused_reason, resets status.consecutive_failures,
+         * and re-arms the clock. Resuming a schedule that is not paused
+         * succeeds and changes nothing. A disabled schedule stays disabled:
+         * resume clears the platform's pause, not the owner's switch
+         * (spec.enabled).
+         *
+         * @internal
+         * Authorization: requires can_edit permission on the schedule — the
+         * update bar; resuming does not change which agent runs, so it does
+         * not re-open create's consent bar (DD-009 C-6). This command is
+         * deliberately the ONLY path that clears a platform auto-pause
+         * (DD-013 D-D): apply and update preserve status byte-for-byte, so a
+         * routine manifest apply can never silently un-pause a failing
+         * schedule. The cloud handler loads before authorizing (#224: a
+         * missing schedule answers NOT_FOUND, not PERMISSION_DENIED) and
+         * patches status leaves rather than saving the row — the tick is a
+         * concurrent status writer. OSS excludes the authorization step, per
+         * its recorded single-user posture.
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.resume
+         */
+        resume: {
+            name: "resume",
+            I: ScheduleId,
+            O: Schedule,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Trigger a schedule to fire once, immediately, and answer with the
+         * run's real outcome.
+         *
+         * The manual fire runs synchronously through the standard execution
+         * create pipeline — every launch gate runs — and the result names what
+         * happened: the created execution's id, or the refusing gate's own
+         * copy verbatim. status.last_fire_at and status.last_execution_id
+         * record a started run. Manual fires do NOT feed the failure streak —
+         * the streak is the unattended (cron) health signal, and a test fire
+         * of a broken schedule must not race its owner to the pause threshold.
+         *
+         * A disabled schedule refuses (enable it first). A platform-paused
+         * schedule MAY be triggered — a test fire is exactly how an owner
+         * verifies a fix before resuming; resume remains the one path that
+         * clears the pause.
+         *
+         * @internal
+         * Authorization: requires can_edit permission on the schedule — the
+         * update bar (DD-014 D-A). Project DD-017 D-5/D-6 amends DD-014: the
+         * artifact round-trip is gone for manual fires (it made the fire
+         * asynchronous, so the RPC answered before the launch gates ran — a
+         * false "run started" beside a climbing failure counter). Cron fires
+         * keep the tracked artifact tick unchanged. The disabled refusal
+         * SURVIVES for a different reason than DD-014 D-B recorded:
+         * ScheduleBlueprintAccess requires spec.enabled at the create gate AND
+         * the mid-run sandbox read predicate, so a disabled-schedule run would
+         * die mid-execution after billing side effects (consoles offer
+         * "Enable & run now" instead; the fire-legitimacy model that would
+         * lift this is DD-017's named follow-up). Two-level contract: a gRPC
+         * error means the trigger itself was refused (disabled →
+         * FAILED_PRECONDITION with the byte-pinned copy, missing → NOT_FOUND
+         * before authorize, #224); a gRPC success means the fire happened and
+         * ScheduleTriggerResult names the run's outcome — a deterministically
+         * refused run is a successful trigger honestly reported, never an
+         * exception. The handler stamps last_fire_at/last_execution_id and
+         * writes the fire-ledger row (origin=manual) because the tick is not
+         * in the path to do it; status writes ride updateFields, never save()
+         * (DD-010 D-B). OSS mirrors the semantics; it excludes the
+         * authorization step per its recorded single-user posture.
+         *
+         * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.trigger
+         */
+        trigger: {
+            name: "trigger",
+            I: ScheduleId,
+            O: ScheduleTriggerResult,
+            kind: MethodKind.Unary,
+        },
+    }
+};
+//# sourceMappingURL=command_connect.js.map

package/ai/stigmer/agentic/schedule/v1/command_connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_connect.js","sourceRoot":"","sources":["../../../../../../ai/stigmer/agentic/schedule/v1/command_connect.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,4HAA4H;AAC5H,oBAAoB;AACpB,cAAc;AAEd,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAE9D;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,QAAQ,EAAE,0DAA0D;IACpE,OAAO,EAAE;QACP;;;;;;;;;;;;;;WAcG;QACH,KAAK,EAAE;YACL,IAAI,EAAE,OAAO;YACb,CAAC,EAAE,QAAQ;YACX,CAAC,EAAE,QAAQ;YACX,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;;;;;;;WAkBG;QACH,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,CAAC,EAAE,QAAQ;YACX,CAAC,EAAE,QAAQ;YACX,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;QACH,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,CAAC,EAAE,QAAQ;YACX,CAAC,EAAE,QAAQ;YACX,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;;;;WAeG;QACH,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,CAAC,EAAE,UAAU;YACb,CAAC,EAAE,QAAQ;YACX,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;;;;;;;;;;;;WAuBG;QACH,MAAM,EAAE;YACN,IAAI,EAAE,QAAQ;YACd,CAAC,EAAE,UAAU;YACb,CAAC,EAAE,QAAQ;YACX,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA0CG;QACH,OAAO,EAAE;YACP,IAAI,EAAE,SAAS;YACf,CAAC,EAAE,UAAU;YACb,CAAC,EAAE,qBAAqB;YACxB,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;KACF;CACO,CAAC"}

package/ai/stigmer/agentic/schedule/v1/command_pb.d.ts

@@ -0,0 +1,187 @@
+import type { GenFile, GenService } from "@bufbuild/protobuf/codegenv1";
+import type { ScheduleSchema } from "./api_pb.js";
+import type { ScheduleIdSchema, ScheduleTriggerResultSchema } from "./io_pb.js";
+/**
+ * Describes the file ai/stigmer/agentic/schedule/v1/command.proto.
+ */
+export declare const file_ai_stigmer_agentic_schedule_v1_command: GenFile;
+/**
+ * ScheduleCommandController handles write operations for schedules.
+ *
+ * @generated from service ai.stigmer.agentic.schedule.v1.ScheduleCommandController
+ */
+export declare const ScheduleCommandController: GenService<{
+    /**
+     * Create or update a schedule.
+     *
+     * @internal
+     * The authorization and state-operation are determined depending on
+     * whether the schedule is going to be created or updated, resolved as
+     * part of request execution. Status is preserved verbatim across
+     * apply-as-update (the AgentChannel decision-004 posture): status is
+     * written only by the scheduling runtime and by the explicit resume
+     * command, and a routine manifest apply must never reset the failure
+     * streak or un-pause a platform-paused schedule (DD-008 D7 / DD-009
+     * pinned behaviors / DD-013 D-D).
+     *
+     * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.apply
+     */
+    apply: {
+        methodKind: "unary";
+        input: typeof ScheduleSchema;
+        output: typeof ScheduleSchema;
+    };
+    /**
+     * Create a schedule.
+     *
+     * Scheduling an agent is a billing-affecting decision: every fire
+     * creates an execution that consumes the schedule-owning
+     * organization's credits, unattended.
+     *
+     * @internal
+     * Authorization: requires can_edit on the REFERENCED AGENT
+     * (spec.agent.agent_ref), checked in-handler — the AgentChannel /
+     * same-org AgentShare Phase A bar (DD-009 C-6): whoever may edit the
+     * agent may schedule it; there is deliberately no org-level
+     * can_create_schedule permission. Standard org-scoped create tuples
+     * (owner = creator); no visibility tuples (the kind has no visibility
+     * block). Invariant enforced here: metadata.org must equal
+     * spec.agent.agent_ref.org.
+     *
+     * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.create
+     */
+    create: {
+        methodKind: "unary";
+        input: typeof ScheduleSchema;
+        output: typeof ScheduleSchema;
+    };
+    /**
+     * Update an existing schedule.
+     *
+     * Replaces the spec wholesale. The slug, the referenced agent, and the
+     * target arm are immutable; cron, time zone, enablement, and the
+     * message may all change. Status (firing observations, the platform
+     * pause) is never touched by updates — use resume to clear a platform
+     * pause.
+     *
+     * @internal
+     * Authorization: requires can_edit permission on the schedule.
+     * agent_ref immutability is a consent-bar guarantee, not convenience
+     * (DD-009 C-7): create's bar is can_edit on the REFERENCED agent, and
+     * a repointing update would let a schedule owner drive an agent they
+     * may not edit — the AgentChannel rule for the AgentChannel reason.
+     * Target-arm immutability (an agent schedule cannot become a workflow
+     * schedule once that arm exists) is enforced in-handler: the two
+     * targets enter different execution pipelines. Update deliberately
+     * does NOT clear a platform auto-pause (DD-013 D-D, superseding the
+     * DD-008 D7 ensure-on-mutate sketch): apply routes through this same
+     * handler, so any update-clears-pause behavior would let a routine
+     * GitOps re-apply silently un-pause a failing schedule. resume is the
+     * one clearing path.
+     *
+     * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.update
+     */
+    update: {
+        methodKind: "unary";
+        input: typeof ScheduleSchema;
+        output: typeof ScheduleSchema;
+    };
+    /**
+     * Delete a schedule.
+     *
+     * Firing stops permanently. Executions created by past fires are
+     * untouched. To stop firing while keeping the schedule and its
+     * history, disable it (enabled=false) instead.
+     *
+     * @internal
+     * Authorization: requires can_delete permission on the schedule. The
+     * referenced agent is untouched. The Temporal artifact teardown
+     * (best-effort, AFTER the row delete — DD-008 D9) arrives with the
+     * clock; until then delete is the row alone, and an orphaned artifact
+     * is harmless by construction (fire-time revalidation no-ops it).
+     *
+     * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.delete
+     */
+    delete: {
+        methodKind: "unary";
+        input: typeof ScheduleIdSchema;
+        output: typeof ScheduleSchema;
+    };
+    /**
+     * Resume a schedule the platform paused after repeated run failures.
+     *
+     * Clears status.paused_reason, resets status.consecutive_failures,
+     * and re-arms the clock. Resuming a schedule that is not paused
+     * succeeds and changes nothing. A disabled schedule stays disabled:
+     * resume clears the platform's pause, not the owner's switch
+     * (spec.enabled).
+     *
+     * @internal
+     * Authorization: requires can_edit permission on the schedule — the
+     * update bar; resuming does not change which agent runs, so it does
+     * not re-open create's consent bar (DD-009 C-6). This command is
+     * deliberately the ONLY path that clears a platform auto-pause
+     * (DD-013 D-D): apply and update preserve status byte-for-byte, so a
+     * routine manifest apply can never silently un-pause a failing
+     * schedule. The cloud handler loads before authorizing (#224: a
+     * missing schedule answers NOT_FOUND, not PERMISSION_DENIED) and
+     * patches status leaves rather than saving the row — the tick is a
+     * concurrent status writer. OSS excludes the authorization step, per
+     * its recorded single-user posture.
+     *
+     * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.resume
+     */
+    resume: {
+        methodKind: "unary";
+        input: typeof ScheduleIdSchema;
+        output: typeof ScheduleSchema;
+    };
+    /**
+     * Trigger a schedule to fire once, immediately, and answer with the
+     * run's real outcome.
+     *
+     * The manual fire runs synchronously through the standard execution
+     * create pipeline — every launch gate runs — and the result names what
+     * happened: the created execution's id, or the refusing gate's own
+     * copy verbatim. status.last_fire_at and status.last_execution_id
+     * record a started run. Manual fires do NOT feed the failure streak —
+     * the streak is the unattended (cron) health signal, and a test fire
+     * of a broken schedule must not race its owner to the pause threshold.
+     *
+     * A disabled schedule refuses (enable it first). A platform-paused
+     * schedule MAY be triggered — a test fire is exactly how an owner
+     * verifies a fix before resuming; resume remains the one path that
+     * clears the pause.
+     *
+     * @internal
+     * Authorization: requires can_edit permission on the schedule — the
+     * update bar (DD-014 D-A). Project DD-017 D-5/D-6 amends DD-014: the
+     * artifact round-trip is gone for manual fires (it made the fire
+     * asynchronous, so the RPC answered before the launch gates ran — a
+     * false "run started" beside a climbing failure counter). Cron fires
+     * keep the tracked artifact tick unchanged. The disabled refusal
+     * SURVIVES for a different reason than DD-014 D-B recorded:
+     * ScheduleBlueprintAccess requires spec.enabled at the create gate AND
+     * the mid-run sandbox read predicate, so a disabled-schedule run would
+     * die mid-execution after billing side effects (consoles offer
+     * "Enable & run now" instead; the fire-legitimacy model that would
+     * lift this is DD-017's named follow-up). Two-level contract: a gRPC
+     * error means the trigger itself was refused (disabled →
+     * FAILED_PRECONDITION with the byte-pinned copy, missing → NOT_FOUND
+     * before authorize, #224); a gRPC success means the fire happened and
+     * ScheduleTriggerResult names the run's outcome — a deterministically
+     * refused run is a successful trigger honestly reported, never an
+     * exception. The handler stamps last_fire_at/last_execution_id and
+     * writes the fire-ledger row (origin=manual) because the tick is not
+     * in the path to do it; status writes ride updateFields, never save()
+     * (DD-010 D-B). OSS mirrors the semantics; it excludes the
+     * authorization step per its recorded single-user posture.
+     *
+     * @generated from rpc ai.stigmer.agentic.schedule.v1.ScheduleCommandController.trigger
+     */
+    trigger: {
+        methodKind: "unary";
+        input: typeof ScheduleIdSchema;
+        output: typeof ScheduleTriggerResultSchema;
+    };
+}>;

package/ai/stigmer/agentic/schedule/v1/command_pb.js

@@ -0,0 +1,19 @@
+// @generated by protoc-gen-es v2.2.2 with parameter "target=ts,import_extension=js"
+// @generated from file ai/stigmer/agentic/schedule/v1/command.proto (package ai.stigmer.agentic.schedule.v1, syntax proto3)
+/* eslint-disable */
+import { fileDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1";
+import { file_ai_stigmer_agentic_schedule_v1_api } from "./api_pb.js";
+import { file_ai_stigmer_agentic_schedule_v1_io } from "./io_pb.js";
+import { file_ai_stigmer_commons_apiresource_rpc_service_options } from "../../../commons/apiresource/rpc_service_options_pb.js";
+import { file_ai_stigmer_commons_rpc_method_options } from "../../../commons/rpc/method_options_pb.js";
+/**
+ * Describes the file ai/stigmer/agentic/schedule/v1/command.proto.
+ */
+export const file_ai_stigmer_agentic_schedule_v1_command = /*@__PURE__*/ fileDesc("CixhaS9zdGlnbWVyL2FnZW50aWMvc2NoZWR1bGUvdjEvY29tbWFuZC5wcm90bxIeYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxMsEGChlTY2hlZHVsZUNvbW1hbmRDb250cm9sbGVyElsKBWFwcGx5EiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlGiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlEmIKBmNyZWF0ZRIoLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZRooLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZSIE0LgYARKUAQoGdXBkYXRlEiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlGiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlIjbCuBgyCAIQOCILbWV0YWRhdGEuaWQqH3VuYXV0aG9yaXplZCB0byB1cGRhdGUgc2NoZWR1bGUSkAEKBmRlbGV0ZRIqLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZUlkGiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlIjDCuBgsCAMQOCIFdmFsdWUqH3VuYXV0aG9yaXplZCB0byBkZWxldGUgc2NoZWR1bGUSkAEKBnJlc3VtZRIqLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZUlkGiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlIjDCuBgsCAIQOCIFdmFsdWUqH3VuYXV0aG9yaXplZCB0byByZXN1bWUgc2NoZWR1bGUSnwEKB3RyaWdnZXISKi5haS5zdGlnbWVyLmFnZW50aWMuc2NoZWR1bGUudjEuU2NoZWR1bGVJZBo1LmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZVRyaWdnZXJSZXN1bHQiMcK4GC0IAhA4IgV2YWx1ZSogdW5hdXRob3JpemVkIHRvIHRyaWdnZXIgc2NoZWR1bGUaBKD/KzhiBnByb3RvMw", [file_ai_stigmer_agentic_schedule_v1_api, file_ai_stigmer_agentic_schedule_v1_io, file_ai_stigmer_commons_apiresource_rpc_service_options, file_ai_stigmer_commons_rpc_method_options]);
+/**
+ * ScheduleCommandController handles write operations for schedules.
+ *
+ * @generated from service ai.stigmer.agentic.schedule.v1.ScheduleCommandController
+ */
+export const ScheduleCommandController = /*@__PURE__*/ serviceDesc(file_ai_stigmer_agentic_schedule_v1_command, 0);
+//# sourceMappingURL=command_pb.js.map

package/ai/stigmer/agentic/schedule/v1/command_pb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"command_pb.js","sourceRoot":"","sources":["../../../../../../ai/stigmer/agentic/schedule/v1/command_pb.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,4HAA4H;AAC5H,oBAAoB;AAGpB,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,uCAAuC,EAAE,MAAM,aAAa,CAAC;AAEtE,OAAO,EAAE,sCAAsC,EAAE,MAAM,YAAY,CAAC;AACpE,OAAO,EAAE,uDAAuD,EAAE,MAAM,wDAAwD,CAAC;AACjI,OAAO,EAAE,0CAA0C,EAAE,MAAM,2CAA2C,CAAC;AAEvG;;GAEG;AACH,MAAM,CAAC,MAAM,2CAA2C,GAAY,aAAa,CAC/E,QAAQ,CAAC,gtCAAgtC,EAAE,CAAC,uCAAuC,EAAE,sCAAsC,EAAE,uDAAuD,EAAE,0CAA0C,CAAC,CAAC,CAAC;AAEr5C;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GA8KjC,aAAa,CAChB,WAAW,CAAC,2CAA2C,EAAE,CAAC,CAAC,CAAC"}