@stigmer/protos 3.6.0 → 3.8.0

package/ai/stigmer/agentic/agentshare/v1/spec_pb.js

@@ -2,13 +2,14 @@
 // @generated from file ai/stigmer/agentic/agentshare/v1/spec.proto (package ai.stigmer.agentic.agentshare.v1, syntax proto3)
 /* eslint-disable */
 import { enumDesc, fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1";
+import { file_ai_stigmer_agentic_agentexecution_v1_invocation } from "../../agentexecution/v1/invocation_pb.js";
 import { file_ai_stigmer_commons_apiresource_field_options } from "../../../commons/apiresource/field_options_pb.js";
 import { file_ai_stigmer_commons_apiresource_io } from "../../../commons/apiresource/io_pb.js";
 import { file_buf_validate_validate } from "../../../../../buf/validate/validate_pb.js";
 /**
  * Describes the file ai/stigmer/agentic/agentshare/v1/spec.proto.
  */
-export const file_ai_stigmer_agentic_agentshare_v1_spec = /*@__PURE__*/ fileDesc("CithaS9zdGlnbWVyL2FnZW50aWMvYWdlbnRzaGFyZS92MS9zcGVjLnByb3RvEiBhaS5zdGlnbWVyLmFnZW50aWMuYWdlbnRzaGFyZS52MSKHCAoOQWdlbnRTaGFyZVNwZWMSrAEKCWFnZW50X3JlZhgBIAEoCzI0LmFpLnN0aWdtZXIuY29tbW9ucy5hcGlyZXNvdXJjZS5BcGlSZXNvdXJjZVJlZmVyZW5jZUJjukhcugFWCg5hZ2VudF9yZWYua2luZBIzYWdlbnRfcmVmIG11c3QgcmVmZXJlbmNlIGEgcmVzb3VyY2Ugd2l0aCBraW5kPWFnZW50Gg90aGlzLmtpbmQgPT0gNDDIAQHghSwoEg8KB2VuYWJsZWQYAiABKAgSRgoIYXVkaWVuY2UYAyABKA4yNC5haS5zdGlnbWVyLmFnZW50aWMuYWdlbnRzaGFyZS52MS5BZ2VudFNoYXJlQXVkaWVuY2USsAIKD2FsbG93ZWRfb3JpZ2lucxgEIAMoCUKWArpIkgKSAY4CECAiiQK6AYUCChZhbGxvd2VkX29yaWdpbnMuZm9ybWF0Em5hbGxvd2VkX29yaWdpbnMgZW50cmllcyBtdXN0IGJlIGV4YWN0IHdlYiBvcmlnaW5zIGxpa2UgaHR0cHM6Ly9leGFtcGxlLmNvbSAobm8gcGF0aCwgcXVlcnksIG9yIHRyYWlsaW5nIHNsYXNoKRp7dGhpcy5tYXRjaGVzKCdeaHR0cHM/Oi8vW0EtWmEtejAtOV0oW0EtWmEtejAtOS1dKltBLVphLXowLTldKT8oXFwuW0EtWmEtejAtOV0oW0EtWmEtejAtOS1dKltBLVphLXowLTldKT8pKig6WzAtOV17MSw1fSk/JCcpEkYKCG1lc3NhZ2VzGAUgASgLMjQuYWkuc3RpZ21lci5hZ2VudGljLmFnZW50c2hhcmUudjEuQWdlbnRTaGFyZU1lc3NhZ2VzEsgBChBlbnZpcm9ubWVudF9yZWZzGAYgAygLMjQuYWkuc3RpZ21lci5jb21tb25zLmFwaXJlc291cmNlLkFwaVJlc291cmNlUmVmZXJlbmNlQni6SHGSAW4ibLoBaQoVZW52aXJvbm1lbnRfcmVmcy5raW5kEj9lbnZpcm9ubWVudF9yZWZzIG11c3QgcmVmZXJlbmNlIHJlc291cmNlcyB3aXRoIGtpbmQ9ZW52aXJvbm1lbnQaD3RoaXMua2luZCA9PSA1M+CFLDU6pgG6SKIBGp8BCihhZ2VudF9zaGFyZS5lbnZpcm9ubWVudF9yZWZzX3B1YmxpY19vbmx5EjplbnZpcm9ubWVudF9yZWZzIGNhbiBvbmx5IGJlIHNldCBvbiBwdWJsaWMtYXVkaWVuY2Ugc2hhcmVzGjd0aGlzLmF1ZGllbmNlICE9IDIgfHwgdGhpcy5lbnZpcm9ubWVudF9yZWZzLnNpemUoKSA9PSAwInkKEkFnZW50U2hhcmVNZXNzYWdlcxIeCgxyYXRlX2xpbWl0ZWQYASABKAlCCLpIBXIDGKwCEh0KC3VuYXZhaWxhYmxlGAIgASgJQgi6SAVyAxisAhIkChJjb252ZXJzYXRpb25fZW5kZWQYAyABKAlCCLpIBXIDGKwCKnkKEkFnZW50U2hhcmVBdWRpZW5jZRIkCiBhZ2VudF9zaGFyZV9hdWRpZW5jZV91bnNwZWNpZmllZBAAEh8KG2FnZW50X3NoYXJlX2F1ZGllbmNlX3B1YmxpYxABEhwKGGFnZW50X3NoYXJlX2F1ZGllbmNlX29yZxACYgZwcm90bzM", [file_ai_stigmer_commons_apiresource_field_options, file_ai_stigmer_commons_apiresource_io, file_buf_validate_validate]);
+export const file_ai_stigmer_agentic_agentshare_v1_spec = /*@__PURE__*/ fileDesc("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", [file_ai_stigmer_agentic_agentexecution_v1_invocation, file_ai_stigmer_commons_apiresource_field_options, file_ai_stigmer_commons_apiresource_io, file_buf_validate_validate]);
 /**
  * Describes the message ai.stigmer.agentic.agentshare.v1.AgentShareSpec.
  * Use `create(AgentShareSpecSchema)` to create a new message.

package/ai/stigmer/agentic/agentshare/v1/spec_pb.js.map

@@ -1 +1 @@
-{"version":3,"file":"spec_pb.js","sourceRoot":"","sources":["../../../../../../ai/stigmer/agentic/agentshare/v1/spec_pb.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,6HAA6H;AAC7H,oBAAoB;AAGpB,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAC/E,OAAO,EAAE,iDAAiD,EAAE,MAAM,kDAAkD,CAAC;AAErH,OAAO,EAAE,sCAAsC,EAAE,MAAM,uCAAuC,CAAC;AAC/F,OAAO,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAGxF;;GAEG;AACH,MAAM,CAAC,MAAM,0CAA0C,GAAY,aAAa,CAC9E,QAAQ,CAAC,iyDAAiyD,EAAE,CAAC,iDAAiD,EAAE,sCAAsC,EAAE,0BAA0B,CAAC,CAAC,CAAC;AAkJv6D;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAA+B,aAAa,CAC3E,WAAW,CAAC,0CAA0C,EAAE,CAAC,CAAC,CAAC;AAmC7D;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAmC,aAAa,CACnF,WAAW,CAAC,0CAA0C,EAAE,CAAC,CAAC,CAAC;AAE7D;;;;;;;GAOG;AACH,MAAM,CAAN,IAAY,kBA0BX;AA1BD,WAAY,kBAAkB;IAC5B;;;;OAIG;IACH,yEAAe,CAAA;IAEf;;;;;;OAMG;IACH,+DAAU,CAAA;IAEV;;;;;;;OAOG;IACH,yDAAO,CAAA;AACT,CAAC,EA1BW,kBAAkB,KAAlB,kBAAkB,QA0B7B;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAgC,aAAa,CAChF,QAAQ,CAAC,0CAA0C,EAAE,CAAC,CAAC,CAAC"}
+{"version":3,"file":"spec_pb.js","sourceRoot":"","sources":["../../../../../../ai/stigmer/agentic/agentshare/v1/spec_pb.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,6HAA6H;AAC7H,oBAAoB;AAGpB,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAE/E,OAAO,EAAE,oDAAoD,EAAE,MAAM,0CAA0C,CAAC;AAChH,OAAO,EAAE,iDAAiD,EAAE,MAAM,kDAAkD,CAAC;AAErH,OAAO,EAAE,sCAAsC,EAAE,MAAM,uCAAuC,CAAC;AAC/F,OAAO,EAAE,0BAA0B,EAAE,MAAM,4CAA4C,CAAC;AAGxF;;GAEG;AACH,MAAM,CAAC,MAAM,0CAA0C,GAAY,aAAa,CAC9E,QAAQ,CAAC,qjEAAqjE,EAAE,CAAC,oDAAoD,EAAE,iDAAiD,EAAE,sCAAsC,EAAE,0BAA0B,CAAC,CAAC,CAAC;AA6KjvE;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAA+B,aAAa,CAC3E,WAAW,CAAC,0CAA0C,EAAE,CAAC,CAAC,CAAC;AAmC7D;;;GAGG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAmC,aAAa,CACnF,WAAW,CAAC,0CAA0C,EAAE,CAAC,CAAC,CAAC;AAE7D;;;;;;;GAOG;AACH,MAAM,CAAN,IAAY,kBA0BX;AA1BD,WAAY,kBAAkB;IAC5B;;;;OAIG;IACH,yEAAe,CAAA;IAEf;;;;;;OAMG;IACH,+DAAU,CAAA;IAEV;;;;;;;OAOG;IACH,yDAAO,CAAA;AACT,CAAC,EA1BW,kBAAkB,KAAlB,kBAAkB,QA0B7B;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAgC,aAAa,CAChF,QAAQ,CAAC,0CAA0C,EAAE,CAAC,CAAC,CAAC"}

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

@@ -137,30 +137,44 @@ export declare const ScheduleCommandController: {
             readonly kind: any;
         };
         /**
-         * Trigger a schedule to fire once, immediately.
-         *
-         * The manual fire runs through the schedule's own clock, so everything
-         * a cron fire does applies: a fresh run is created, status.last_fire_at
-         * and status.last_execution_id record it, and its verdict feeds the
-         * failure streak (a successful manual fire resets the streak). The fire
-         * is asynchronous — the response carries the schedule, and the run
-         * appears on status as it starts. A disabled schedule refuses (enable
-         * it first); a platform-paused schedule refuses (resume it first).
+         * 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 in the whatsapp-proactive-messaging project).
-         * Refusal matrix in-handler (DD-014 D-B): disabled and paused both
-         * answer FAILED_PRECONDITION with teaching copy; the cloud handler
-         * loads before authorizing (#224: a missing schedule answers NOT_FOUND,
-         * not PERMISSION_DENIED). The manual fire bypasses the artifact's SKIP
-         * overlap policy (ALLOW_ALL — DD-014 D-C): since a tick SPANS its run,
-         * SKIP would silently swallow a trigger issued while a previous fire is
-         * still tracking, and a human asking to run now means now. Cron fires
-         * keep SKIP, baked into the artifact. Manual fires feed the failure
-         * streak and reset it on success (DD-014 D-D): one verdict path, no
-         * manual-fire exemption. OSS answers FAILED_PRECONDITION until its
-         * clock lands (T04 slice 3a), then fires for real; OSS excludes 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

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

@@ -4,7 +4,7 @@
 // @ts-nocheck
 import { Schedule } from "./api_pbjs";
 import { MethodKind } from "@bufbuild/protobuf";
-import { ScheduleId } from "./io_pbjs";
+import { ScheduleId, ScheduleTriggerResult } from "./io_pbjs";
 /**
  * ScheduleCommandController handles write operations for schedules.
  *
@@ -144,30 +144,44 @@ export const ScheduleCommandController = {
             kind: MethodKind.Unary,
         },
         /**
-         * Trigger a schedule to fire once, immediately.
-         *
-         * The manual fire runs through the schedule's own clock, so everything
-         * a cron fire does applies: a fresh run is created, status.last_fire_at
-         * and status.last_execution_id record it, and its verdict feeds the
-         * failure streak (a successful manual fire resets the streak). The fire
-         * is asynchronous — the response carries the schedule, and the run
-         * appears on status as it starts. A disabled schedule refuses (enable
-         * it first); a platform-paused schedule refuses (resume it first).
+         * 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 in the whatsapp-proactive-messaging project).
-         * Refusal matrix in-handler (DD-014 D-B): disabled and paused both
-         * answer FAILED_PRECONDITION with teaching copy; the cloud handler
-         * loads before authorizing (#224: a missing schedule answers NOT_FOUND,
-         * not PERMISSION_DENIED). The manual fire bypasses the artifact's SKIP
-         * overlap policy (ALLOW_ALL — DD-014 D-C): since a tick SPANS its run,
-         * SKIP would silently swallow a trigger issued while a previous fire is
-         * still tracking, and a human asking to run now means now. Cron fires
-         * keep SKIP, baked into the artifact. Manual fires feed the failure
-         * streak and reset it on success (DD-014 D-D): one verdict path, no
-         * manual-fire exemption. OSS answers FAILED_PRECONDITION until its
-         * clock lands (T04 slice 3a), then fires for real; OSS excludes 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
@@ -175,7 +189,7 @@ export const ScheduleCommandController = {
         trigger: {
             name: "trigger",
             I: ScheduleId,
-            O: Schedule,
+            O: ScheduleTriggerResult,
             kind: MethodKind.Unary,
         },
     }

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

@@ -1 +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,MAAM,WAAW,CAAC;AAEvC;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;WA4BG;QACH,OAAO,EAAE;YACP,IAAI,EAAE,SAAS;YACf,CAAC,EAAE,UAAU;YACb,CAAC,EAAE,QAAQ;YACX,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;KACF;CACO,CAAC"}
+{"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

@@ -1,6 +1,6 @@
 import type { GenFile, GenService } from "@bufbuild/protobuf/codegenv1";
 import type { ScheduleSchema } from "./api_pb.js";
-import type { ScheduleIdSchema } from "./io_pb.js";
+import type { ScheduleIdSchema, ScheduleTriggerResultSchema } from "./io_pb.js";
 /**
  * Describes the file ai/stigmer/agentic/schedule/v1/command.proto.
  */
@@ -137,30 +137,44 @@ export declare const ScheduleCommandController: GenService<{
         output: typeof ScheduleSchema;
     };
     /**
-     * Trigger a schedule to fire once, immediately.
-     *
-     * The manual fire runs through the schedule's own clock, so everything
-     * a cron fire does applies: a fresh run is created, status.last_fire_at
-     * and status.last_execution_id record it, and its verdict feeds the
-     * failure streak (a successful manual fire resets the streak). The fire
-     * is asynchronous — the response carries the schedule, and the run
-     * appears on status as it starts. A disabled schedule refuses (enable
-     * it first); a platform-paused schedule refuses (resume it first).
+     * 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 in the whatsapp-proactive-messaging project).
-     * Refusal matrix in-handler (DD-014 D-B): disabled and paused both
-     * answer FAILED_PRECONDITION with teaching copy; the cloud handler
-     * loads before authorizing (#224: a missing schedule answers NOT_FOUND,
-     * not PERMISSION_DENIED). The manual fire bypasses the artifact's SKIP
-     * overlap policy (ALLOW_ALL — DD-014 D-C): since a tick SPANS its run,
-     * SKIP would silently swallow a trigger issued while a previous fire is
-     * still tracking, and a human asking to run now means now. Cron fires
-     * keep SKIP, baked into the artifact. Manual fires feed the failure
-     * streak and reset it on success (DD-014 D-D): one verdict path, no
-     * manual-fire exemption. OSS answers FAILED_PRECONDITION until its
-     * clock lands (T04 slice 3a), then fires for real; OSS excludes 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
@@ -168,6 +182,6 @@ export declare const ScheduleCommandController: GenService<{
     trigger: {
         methodKind: "unary";
         input: typeof ScheduleIdSchema;
-        output: typeof ScheduleSchema;
+        output: typeof ScheduleTriggerResultSchema;
     };
 }>;

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

@@ -9,7 +9,7 @@ import { file_ai_stigmer_commons_rpc_method_options } from "../../../commons/rpc
 /**
  * Describes the file ai/stigmer/agentic/schedule/v1/command.proto.
  */
-export const file_ai_stigmer_agentic_schedule_v1_command = /*@__PURE__*/ fileDesc("CixhaS9zdGlnbWVyL2FnZW50aWMvc2NoZWR1bGUvdjEvY29tbWFuZC5wcm90bxIeYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxMrQGChlTY2hlZHVsZUNvbW1hbmRDb250cm9sbGVyElsKBWFwcGx5EiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlGiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlEmIKBmNyZWF0ZRIoLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZRooLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZSIE0LgYARKUAQoGdXBkYXRlEiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlGiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlIjbCuBgyCAIQOCILbWV0YWRhdGEuaWQqH3VuYXV0aG9yaXplZCB0byB1cGRhdGUgc2NoZWR1bGUSkAEKBmRlbGV0ZRIqLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZUlkGiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlIjDCuBgsCAMQOCIFdmFsdWUqH3VuYXV0aG9yaXplZCB0byBkZWxldGUgc2NoZWR1bGUSkAEKBnJlc3VtZRIqLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZUlkGiguYWkuc3RpZ21lci5hZ2VudGljLnNjaGVkdWxlLnYxLlNjaGVkdWxlIjDCuBgsCAIQOCIFdmFsdWUqH3VuYXV0aG9yaXplZCB0byByZXN1bWUgc2NoZWR1bGUSkgEKB3RyaWdnZXISKi5haS5zdGlnbWVyLmFnZW50aWMuc2NoZWR1bGUudjEuU2NoZWR1bGVJZBooLmFpLnN0aWdtZXIuYWdlbnRpYy5zY2hlZHVsZS52MS5TY2hlZHVsZSIxwrgYLQgCEDgiBXZhbHVlKiB1bmF1dGhvcml6ZWQgdG8gdHJpZ2dlciBzY2hlZHVsZRoEoP8rOGIGcHJvdG8z", [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]);
+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.
  *

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

@@ -1 +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,8rCAA8rC,EAAE,CAAC,uCAAuC,EAAE,sCAAsC,EAAE,uDAAuD,EAAE,0CAA0C,CAAC,CAAC,CAAC;AAEn4C;;;;GAIG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAgKjC,aAAa,CAChB,WAAW,CAAC,2CAA2C,EAAE,CAAC,CAAC,CAAC"}
+{"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"}

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

@@ -1,6 +1,7 @@
-import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1";
+import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1";
 import type { Schedule } from "./api_pb.js";
 import type { PageInfo } from "../../../commons/rpc/pagination_pb.js";
+import type { Timestamp } from "@bufbuild/protobuf/wkt";
 import type { Message } from "@bufbuild/protobuf";
 /**
  * Describes the file ai/stigmer/agentic/schedule/v1/io.proto.
@@ -120,3 +121,267 @@ export type ListSchedulesRequest = Message<"ai.stigmer.agentic.schedule.v1.ListS
  * Use `create(ListSchedulesRequestSchema)` to create a new message.
  */
 export declare const ListSchedulesRequestSchema: GenMessage<ListSchedulesRequest>;
+/**
+ * Result of manually triggering a schedule.
+ *
+ * A gRPC error means the trigger itself was refused (disabled schedule,
+ * missing schedule, unauthorized). A successful response means the fire
+ * happened, and this message names the run's real outcome.
+ *
+ * @generated from message ai.stigmer.agentic.schedule.v1.ScheduleTriggerResult
+ */
+export type ScheduleTriggerResult = Message<"ai.stigmer.agentic.schedule.v1.ScheduleTriggerResult"> & {
+    /**
+     * The schedule after the fire, status freshly stamped.
+     *
+     * @generated from field: ai.stigmer.agentic.schedule.v1.Schedule schedule = 1;
+     */
+    schedule?: Schedule;
+    /**
+     * What the fire produced: STARTED, REFUSED, or TARGET_MISSING (the
+     * terminal outcomes belong to run history — a manual fire answers at
+     * run start).
+     *
+     * @generated from field: ai.stigmer.agentic.schedule.v1.ScheduleRunOutcome outcome = 2;
+     */
+    outcome: ScheduleRunOutcome;
+    /**
+     * ID of the created execution. Set only when outcome is STARTED.
+     *
+     * @generated from field: string execution_id = 3;
+     */
+    executionId: string;
+    /**
+     * The refusing launch gate's copy, verbatim. Set only when outcome is
+     * REFUSED or TARGET_MISSING.
+     *
+     * @generated from field: string refusal_reason = 4;
+     */
+    refusalReason: string;
+};
+/**
+ * Describes the message ai.stigmer.agentic.schedule.v1.ScheduleTriggerResult.
+ * Use `create(ScheduleTriggerResultSchema)` to create a new message.
+ */
+export declare const ScheduleTriggerResultSchema: GenMessage<ScheduleTriggerResult>;
+/**
+ * One recorded schedule fire — a run-history row.
+ *
+ * @internal
+ * Backed by the fire ledger (project DD-017 D-7): every fire leaves a
+ * row, INCLUDING fires that created no execution — the ledger is the
+ * one place a refused fire's reason survives below the pause threshold.
+ * Rows carrying an execution id but no terminal outcome are enriched
+ * with the execution's live phase at read time, so outcome never lies
+ * while a run is in flight.
+ *
+ * @generated from message ai.stigmer.agentic.schedule.v1.ScheduleRun
+ */
+export type ScheduleRun = Message<"ai.stigmer.agentic.schedule.v1.ScheduleRun"> & {
+    /**
+     * Schedule this fire belongs to.
+     *
+     * @generated from field: string schedule_id = 1;
+     */
+    scheduleId: string;
+    /**
+     * Organization that owns the schedule.
+     *
+     * @generated from field: string org = 2;
+     */
+    org: string;
+    /**
+     * The fire's nominal time (cron: the scheduled instant; manual: the
+     * trigger instant).
+     *
+     * @generated from field: google.protobuf.Timestamp nominal_fire_time = 3;
+     */
+    nominalFireTime?: Timestamp;
+    /**
+     * How the fire was initiated.
+     *
+     * @generated from field: ai.stigmer.agentic.schedule.v1.ScheduleRunOrigin origin = 4;
+     */
+    origin: ScheduleRunOrigin;
+    /**
+     * What the fire produced.
+     *
+     * @generated from field: ai.stigmer.agentic.schedule.v1.ScheduleRunOutcome outcome = 5;
+     */
+    outcome: ScheduleRunOutcome;
+    /**
+     * The refusing gate's or terminal verdict's copy, verbatim. Empty for
+     * healthy outcomes.
+     *
+     * @generated from field: string reason = 6;
+     */
+    reason: string;
+    /**
+     * ID of the created execution. Empty when no execution was created
+     * (refused, target missing, skipped).
+     *
+     * @generated from field: string execution_id = 7;
+     */
+    executionId: string;
+    /**
+     * When the fire was recorded.
+     *
+     * @generated from field: google.protobuf.Timestamp recorded_at = 8;
+     */
+    recordedAt?: Timestamp;
+    /**
+     * When the terminal outcome was recorded. Absent while the run is in
+     * flight or when no run was created.
+     *
+     * @generated from field: google.protobuf.Timestamp completed_at = 9;
+     */
+    completedAt?: Timestamp;
+};
+/**
+ * Describes the message ai.stigmer.agentic.schedule.v1.ScheduleRun.
+ * Use `create(ScheduleRunSchema)` to create a new message.
+ */
+export declare const ScheduleRunSchema: GenMessage<ScheduleRun>;
+/**
+ * Input for listing a schedule's run history.
+ *
+ * @generated from message ai.stigmer.agentic.schedule.v1.ListScheduleRunsRequest
+ */
+export type ListScheduleRunsRequest = Message<"ai.stigmer.agentic.schedule.v1.ListScheduleRunsRequest"> & {
+    /**
+     * Schedule whose runs to list.
+     *
+     * @generated from field: string schedule_id = 1;
+     */
+    scheduleId: string;
+    /**
+     * Pagination options. Runs are returned newest first.
+     *
+     * @generated from field: ai.stigmer.commons.rpc.PageInfo page_info = 2;
+     */
+    pageInfo?: PageInfo;
+};
+/**
+ * Describes the message ai.stigmer.agentic.schedule.v1.ListScheduleRunsRequest.
+ * Use `create(ListScheduleRunsRequestSchema)` to create a new message.
+ */
+export declare const ListScheduleRunsRequestSchema: GenMessage<ListScheduleRunsRequest>;
+/**
+ * Response containing a paginated list of schedule runs, newest first.
+ *
+ * @generated from message ai.stigmer.agentic.schedule.v1.ScheduleRunList
+ */
+export type ScheduleRunList = Message<"ai.stigmer.agentic.schedule.v1.ScheduleRunList"> & {
+    /**
+     * Total number of recorded runs for the schedule.
+     *
+     * @generated from field: int32 total_count = 1;
+     */
+    totalCount: number;
+    /**
+     * Runs in the current page.
+     *
+     * @generated from field: repeated ai.stigmer.agentic.schedule.v1.ScheduleRun items = 2;
+     */
+    items: ScheduleRun[];
+};
+/**
+ * Describes the message ai.stigmer.agentic.schedule.v1.ScheduleRunList.
+ * Use `create(ScheduleRunListSchema)` to create a new message.
+ */
+export declare const ScheduleRunListSchema: GenMessage<ScheduleRunList>;
+/**
+ * How a schedule fire was initiated.
+ *
+ * @generated from enum ai.stigmer.agentic.schedule.v1.ScheduleRunOrigin
+ */
+export declare enum ScheduleRunOrigin {
+    /**
+     * @generated from enum value: SCHEDULE_RUN_ORIGIN_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * The clock fired the schedule on its cron cadence.
+     *
+     * @generated from enum value: SCHEDULE_RUN_ORIGIN_CRON = 1;
+     */
+    CRON = 1,
+    /**
+     * A caller fired the schedule through the trigger command.
+     *
+     * @generated from enum value: SCHEDULE_RUN_ORIGIN_MANUAL = 2;
+     */
+    MANUAL = 2
+}
+/**
+ * Describes the enum ai.stigmer.agentic.schedule.v1.ScheduleRunOrigin.
+ */
+export declare const ScheduleRunOriginSchema: GenEnum<ScheduleRunOrigin>;
+/**
+ * What one schedule fire produced.
+ *
+ * @internal
+ * One vocabulary for two surfaces (project DD-017 D-6/D-7): the trigger
+ * result reports the START outcomes (STARTED / REFUSED /
+ * TARGET_MISSING), and the run-history rows additionally reach the
+ * terminal outcomes (COMPLETED / FAILED / TIMED_OUT) written by the cron
+ * tick's tracking. SKIPPED records a cron fire that revalidated against
+ * a row deleted/disabled/paused between recording and starting.
+ *
+ * @generated from enum ai.stigmer.agentic.schedule.v1.ScheduleRunOutcome
+ */
+export declare enum ScheduleRunOutcome {
+    /**
+     * @generated from enum value: SCHEDULE_RUN_OUTCOME_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * An execution was created (or idempotently re-found) and is running.
+     *
+     * @generated from enum value: SCHEDULE_RUN_OUTCOME_STARTED = 1;
+     */
+    STARTED = 1,
+    /**
+     * A launch gate refused the run deterministically; reason carries the
+     * gate's copy verbatim.
+     *
+     * @generated from enum value: SCHEDULE_RUN_OUTCOME_REFUSED = 2;
+     */
+    REFUSED = 2,
+    /**
+     * The schedule's agent_ref no longer resolves.
+     *
+     * @generated from enum value: SCHEDULE_RUN_OUTCOME_TARGET_MISSING = 3;
+     */
+    TARGET_MISSING = 3,
+    /**
+     * The fire no-opped: the row was deleted, disabled, or paused between
+     * the fire being recorded and the run starting.
+     *
+     * @generated from enum value: SCHEDULE_RUN_OUTCOME_SKIPPED = 4;
+     */
+    SKIPPED = 4,
+    /**
+     * The tracked run reached EXECUTION_COMPLETED.
+     *
+     * @generated from enum value: SCHEDULE_RUN_OUTCOME_COMPLETED = 5;
+     */
+    COMPLETED = 5,
+    /**
+     * The tracked run ended terminal-but-not-completed (failed, cancelled,
+     * or terminated); reason names the terminal phase.
+     *
+     * @generated from enum value: SCHEDULE_RUN_OUTCOME_FAILED = 6;
+     */
+    FAILED = 6,
+    /**
+     * The tracked run outlived the fire's tracking budget.
+     *
+     * @generated from enum value: SCHEDULE_RUN_OUTCOME_TIMED_OUT = 7;
+     */
+    TIMED_OUT = 7
+}
+/**
+ * Describes the enum ai.stigmer.agentic.schedule.v1.ScheduleRunOutcome.
+ */
+export declare const ScheduleRunOutcomeSchema: GenEnum<ScheduleRunOutcome>;