@stigmer/protos 3.6.0 → 3.7.0

package/ai/stigmer/agentic/agentchannel/v1/conversation_command_connect.d.ts

@@ -0,0 +1,141 @@
+/**
+ * ChannelConversationCommandController operates a conversation's
+ * participation state: staff replies, takeover and handback of the control
+ * token, attention management, and the agent's escalation ingest.
+ *
+ * @internal
+ * channel-conversations DD-003 D-f (takeOver/handBack), DD-008 D-d
+ * (escalate), DD-009 D-a (reply), DD-010 D-b (the permission map). Two
+ * audiences on one controller, split per method: the four human-facing
+ * commands authorize declaratively on the channel with can_participate
+ * (participants are org humans who may speak to the channel's customers
+ * as the business — NOT channel configurators); escalate is agent-audience
+ * only, session-bound, with identity derived server-side. Every state
+ * transition funnels through the single participation writer (DD-003 D-c)
+ * — CAS-guarded, one winner under concurrent takeover. Cloud-first
+ * runtime: the OSS edition refuses every command FAILED_PRECONDITION (the
+ * sendMessage posture). Never hangs, never lies.
+ *
+ * @generated from service ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController
+ */
+export declare const ChannelConversationCommandController: {
+    readonly typeName: "ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController";
+    readonly methods: {
+        /**
+         * Reply to a conversation as the business, through the same number the
+         * agent serves.
+         *
+         * The message is durably recorded and attempted inline; the outcome
+         * reports the truth of the attempt. A staff reply on an agent-held
+         * conversation is an implicit takeover: the agent goes quiet until
+         * handBack. Replying requires an existing conversation — the customer
+         * must have written first; an unknown conversation answers NOT_FOUND.
+         *
+         * @internal
+         * channel-conversations DD-009: rides the outbound lane with the
+         * participant origin (amended by T03 Sitting 1's A1 — operator cannot
+         * distinguish a staff reply from a console cold-send, so the cap
+         * predicate would have nothing to key on), recipient derived from the
+         * conversation key (never an argument — the origin trap D-a dissolves),
+         * exempt from the proactive caps and the proactive consent lever
+         * (D-b/D-c: reply traffic inside the open service window; the authority
+         * bar is the control). The existing-conversation precondition is T03
+         * Sitting 2's A8, making D-c's "a customer who already wrote to us"
+         * literal: without it, this lane would be an uncapped, lever-free
+         * cold-send reachable below the sendMessage authority bar. The
+         * implicit-takeover flip orders before-or-with the send (T03).
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.reply
+         */
+        readonly reply: {
+            readonly name: "reply";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Take over a conversation: the agent goes quiet until handBack.
+         *
+         * Taking over also clears the needs-attention flag — the human arriving
+         * is the answer to an escalation.
+         *
+         * @internal
+         * channel-conversations DD-005 (the suppression this arms), DD-007 D-f
+         * (CAS WHERE control='agent'; two concurrent attempts resolve to one
+         * winner, the loser receives the fresh state), DD-008 D-f (attention
+         * cleared on takeover).
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.takeOver
+         */
+        readonly takeOver: {
+            readonly name: "takeOver";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Hand a conversation back to the agent, restoring automatic replies.
+         *
+         * The agent re-enters with the conversation context it missed while the
+         * human held control.
+         *
+         * @internal
+         * channel-conversations DD-007: CAS WHERE control='human'; any holder
+         * of can_participate may hand back, not only the takeover holder (v1
+         * single attention pool). Handback never touches the attention flag
+         * (DD-002 D-a #4). The missed-context digest is composed lazily at the
+         * next turn from the agent_witnessed_through watermark, not here.
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.handBack
+         */
+        readonly handBack: {
+            readonly name: "handBack";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Clear a conversation's needs-attention flag without taking it over.
+         *
+         * The false-alarm dismissal: an escalation that needs no reply is
+         * cleared in place, never via a take-over-and-hand-back dance.
+         *
+         * @internal
+         * channel-conversations DD-008 D-f. Control is untouched; the clear is
+         * recorded on the conversation's event history through the
+         * participation writer.
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.clearAttention
+         */
+        readonly clearAttention: {
+            readonly name: "clearAttention";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+        /**
+         * Flag this conversation for human attention.
+         *
+         * Non-blocking: the agent keeps serving while the flag summons humans.
+         * Repeated escalation is harmless; the latest reason wins.
+         *
+         * @internal
+         * channel-conversations DD-008: agent-audience only — session-bound
+         * sandbox tokens; the conversation identity derives server-side from
+         * the session's channel labels (never caller-supplied, the DD-003
+         * identity doctrine), so the input carries only the reason. Appends an
+         * internal-lane escalation event and updates the row projection through
+         * the participation writer, idempotently. Approval-free by construction
+         * (unattended surfaces skip gated tools — a gated escalation would
+         * never fire). Cloud-first runtime; OSS refuses FAILED_PRECONDITION.
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.escalate
+         */
+        readonly escalate: {
+            readonly name: "escalate";
+            readonly I: any;
+            readonly O: any;
+            readonly kind: any;
+        };
+    };
+};

package/ai/stigmer/agentic/agentchannel/v1/conversation_command_connect.js

@@ -0,0 +1,149 @@
+// @generated by protoc-gen-connect-es v1.6.1 with parameter "target=ts,import_extension=js"
+// @generated from file ai/stigmer/agentic/agentchannel/v1/conversation_command.proto (package ai.stigmer.agentic.agentchannel.v1, syntax proto3)
+/* eslint-disable */
+// @ts-nocheck
+import { ChannelConversation, ConversationControlInput, EscalateConversationInput, ReplyToConversationInput } from "./conversation_io_pbjs";
+import { SendChannelMessageOutput } from "./message_io_pbjs";
+import { MethodKind } from "@bufbuild/protobuf";
+/**
+ * ChannelConversationCommandController operates a conversation's
+ * participation state: staff replies, takeover and handback of the control
+ * token, attention management, and the agent's escalation ingest.
+ *
+ * @internal
+ * channel-conversations DD-003 D-f (takeOver/handBack), DD-008 D-d
+ * (escalate), DD-009 D-a (reply), DD-010 D-b (the permission map). Two
+ * audiences on one controller, split per method: the four human-facing
+ * commands authorize declaratively on the channel with can_participate
+ * (participants are org humans who may speak to the channel's customers
+ * as the business — NOT channel configurators); escalate is agent-audience
+ * only, session-bound, with identity derived server-side. Every state
+ * transition funnels through the single participation writer (DD-003 D-c)
+ * — CAS-guarded, one winner under concurrent takeover. Cloud-first
+ * runtime: the OSS edition refuses every command FAILED_PRECONDITION (the
+ * sendMessage posture). Never hangs, never lies.
+ *
+ * @generated from service ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController
+ */
+export const ChannelConversationCommandController = {
+    typeName: "ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController",
+    methods: {
+        /**
+         * Reply to a conversation as the business, through the same number the
+         * agent serves.
+         *
+         * The message is durably recorded and attempted inline; the outcome
+         * reports the truth of the attempt. A staff reply on an agent-held
+         * conversation is an implicit takeover: the agent goes quiet until
+         * handBack. Replying requires an existing conversation — the customer
+         * must have written first; an unknown conversation answers NOT_FOUND.
+         *
+         * @internal
+         * channel-conversations DD-009: rides the outbound lane with the
+         * participant origin (amended by T03 Sitting 1's A1 — operator cannot
+         * distinguish a staff reply from a console cold-send, so the cap
+         * predicate would have nothing to key on), recipient derived from the
+         * conversation key (never an argument — the origin trap D-a dissolves),
+         * exempt from the proactive caps and the proactive consent lever
+         * (D-b/D-c: reply traffic inside the open service window; the authority
+         * bar is the control). The existing-conversation precondition is T03
+         * Sitting 2's A8, making D-c's "a customer who already wrote to us"
+         * literal: without it, this lane would be an uncapped, lever-free
+         * cold-send reachable below the sendMessage authority bar. The
+         * implicit-takeover flip orders before-or-with the send (T03).
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.reply
+         */
+        reply: {
+            name: "reply",
+            I: ReplyToConversationInput,
+            O: SendChannelMessageOutput,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Take over a conversation: the agent goes quiet until handBack.
+         *
+         * Taking over also clears the needs-attention flag — the human arriving
+         * is the answer to an escalation.
+         *
+         * @internal
+         * channel-conversations DD-005 (the suppression this arms), DD-007 D-f
+         * (CAS WHERE control='agent'; two concurrent attempts resolve to one
+         * winner, the loser receives the fresh state), DD-008 D-f (attention
+         * cleared on takeover).
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.takeOver
+         */
+        takeOver: {
+            name: "takeOver",
+            I: ConversationControlInput,
+            O: ChannelConversation,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Hand a conversation back to the agent, restoring automatic replies.
+         *
+         * The agent re-enters with the conversation context it missed while the
+         * human held control.
+         *
+         * @internal
+         * channel-conversations DD-007: CAS WHERE control='human'; any holder
+         * of can_participate may hand back, not only the takeover holder (v1
+         * single attention pool). Handback never touches the attention flag
+         * (DD-002 D-a #4). The missed-context digest is composed lazily at the
+         * next turn from the agent_witnessed_through watermark, not here.
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.handBack
+         */
+        handBack: {
+            name: "handBack",
+            I: ConversationControlInput,
+            O: ChannelConversation,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Clear a conversation's needs-attention flag without taking it over.
+         *
+         * The false-alarm dismissal: an escalation that needs no reply is
+         * cleared in place, never via a take-over-and-hand-back dance.
+         *
+         * @internal
+         * channel-conversations DD-008 D-f. Control is untouched; the clear is
+         * recorded on the conversation's event history through the
+         * participation writer.
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.clearAttention
+         */
+        clearAttention: {
+            name: "clearAttention",
+            I: ConversationControlInput,
+            O: ChannelConversation,
+            kind: MethodKind.Unary,
+        },
+        /**
+         * Flag this conversation for human attention.
+         *
+         * Non-blocking: the agent keeps serving while the flag summons humans.
+         * Repeated escalation is harmless; the latest reason wins.
+         *
+         * @internal
+         * channel-conversations DD-008: agent-audience only — session-bound
+         * sandbox tokens; the conversation identity derives server-side from
+         * the session's channel labels (never caller-supplied, the DD-003
+         * identity doctrine), so the input carries only the reason. Appends an
+         * internal-lane escalation event and updates the row projection through
+         * the participation writer, idempotently. Approval-free by construction
+         * (unattended surfaces skip gated tools — a gated escalation would
+         * never fire). Cloud-first runtime; OSS refuses FAILED_PRECONDITION.
+         *
+         * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.escalate
+         */
+        escalate: {
+            name: "escalate",
+            I: EscalateConversationInput,
+            O: ChannelConversation,
+            kind: MethodKind.Unary,
+        },
+    }
+};
+//# sourceMappingURL=conversation_command_connect.js.map

package/ai/stigmer/agentic/agentchannel/v1/conversation_command_connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation_command_connect.js","sourceRoot":"","sources":["../../../../../../ai/stigmer/agentic/agentchannel/v1/conversation_command_connect.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,iJAAiJ;AACjJ,oBAAoB;AACpB,cAAc;AAEd,OAAO,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,wBAAwB,EAAE,MAAM,wBAAwB,CAAC;AAC5I,OAAO,EAAE,wBAAwB,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG;IAClD,QAAQ,EAAE,yEAAyE;IACnF,OAAO,EAAE;QACP;;;;;;;;;;;;;;;;;;;;;;;;;WAyBG;QACH,KAAK,EAAE;YACL,IAAI,EAAE,OAAO;YACb,CAAC,EAAE,wBAAwB;YAC3B,CAAC,EAAE,wBAAwB;YAC3B,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;;WAaG;QACH,QAAQ,EAAE;YACR,IAAI,EAAE,UAAU;YAChB,CAAC,EAAE,wBAAwB;YAC3B,CAAC,EAAE,mBAAmB;YACtB,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;;;WAcG;QACH,QAAQ,EAAE;YACR,IAAI,EAAE,UAAU;YAChB,CAAC,EAAE,wBAAwB;YAC3B,CAAC,EAAE,mBAAmB;YACtB,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;WAYG;QACH,cAAc,EAAE;YACd,IAAI,EAAE,gBAAgB;YACtB,CAAC,EAAE,wBAAwB;YAC3B,CAAC,EAAE,mBAAmB;YACtB,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;QACD;;;;;;;;;;;;;;;;;WAiBG;QACH,QAAQ,EAAE;YACR,IAAI,EAAE,UAAU;YAChB,CAAC,EAAE,yBAAyB;YAC5B,CAAC,EAAE,mBAAmB;YACtB,IAAI,EAAE,UAAU,CAAC,KAAK;SACvB;KACF;CACO,CAAC"}

package/ai/stigmer/agentic/agentchannel/v1/conversation_command_pb.d.ts

@@ -0,0 +1,140 @@
+import type { GenFile, GenService } from "@bufbuild/protobuf/codegenv1";
+import type { ChannelConversationSchema, ConversationControlInputSchema, EscalateConversationInputSchema, ReplyToConversationInputSchema } from "./conversation_io_pb.js";
+import type { SendChannelMessageOutputSchema } from "./message_io_pb.js";
+/**
+ * Describes the file ai/stigmer/agentic/agentchannel/v1/conversation_command.proto.
+ */
+export declare const file_ai_stigmer_agentic_agentchannel_v1_conversation_command: GenFile;
+/**
+ * ChannelConversationCommandController operates a conversation's
+ * participation state: staff replies, takeover and handback of the control
+ * token, attention management, and the agent's escalation ingest.
+ *
+ * @internal
+ * channel-conversations DD-003 D-f (takeOver/handBack), DD-008 D-d
+ * (escalate), DD-009 D-a (reply), DD-010 D-b (the permission map). Two
+ * audiences on one controller, split per method: the four human-facing
+ * commands authorize declaratively on the channel with can_participate
+ * (participants are org humans who may speak to the channel's customers
+ * as the business — NOT channel configurators); escalate is agent-audience
+ * only, session-bound, with identity derived server-side. Every state
+ * transition funnels through the single participation writer (DD-003 D-c)
+ * — CAS-guarded, one winner under concurrent takeover. Cloud-first
+ * runtime: the OSS edition refuses every command FAILED_PRECONDITION (the
+ * sendMessage posture). Never hangs, never lies.
+ *
+ * @generated from service ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController
+ */
+export declare const ChannelConversationCommandController: GenService<{
+    /**
+     * Reply to a conversation as the business, through the same number the
+     * agent serves.
+     *
+     * The message is durably recorded and attempted inline; the outcome
+     * reports the truth of the attempt. A staff reply on an agent-held
+     * conversation is an implicit takeover: the agent goes quiet until
+     * handBack. Replying requires an existing conversation — the customer
+     * must have written first; an unknown conversation answers NOT_FOUND.
+     *
+     * @internal
+     * channel-conversations DD-009: rides the outbound lane with the
+     * participant origin (amended by T03 Sitting 1's A1 — operator cannot
+     * distinguish a staff reply from a console cold-send, so the cap
+     * predicate would have nothing to key on), recipient derived from the
+     * conversation key (never an argument — the origin trap D-a dissolves),
+     * exempt from the proactive caps and the proactive consent lever
+     * (D-b/D-c: reply traffic inside the open service window; the authority
+     * bar is the control). The existing-conversation precondition is T03
+     * Sitting 2's A8, making D-c's "a customer who already wrote to us"
+     * literal: without it, this lane would be an uncapped, lever-free
+     * cold-send reachable below the sendMessage authority bar. The
+     * implicit-takeover flip orders before-or-with the send (T03).
+     *
+     * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.reply
+     */
+    reply: {
+        methodKind: "unary";
+        input: typeof ReplyToConversationInputSchema;
+        output: typeof SendChannelMessageOutputSchema;
+    };
+    /**
+     * Take over a conversation: the agent goes quiet until handBack.
+     *
+     * Taking over also clears the needs-attention flag — the human arriving
+     * is the answer to an escalation.
+     *
+     * @internal
+     * channel-conversations DD-005 (the suppression this arms), DD-007 D-f
+     * (CAS WHERE control='agent'; two concurrent attempts resolve to one
+     * winner, the loser receives the fresh state), DD-008 D-f (attention
+     * cleared on takeover).
+     *
+     * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.takeOver
+     */
+    takeOver: {
+        methodKind: "unary";
+        input: typeof ConversationControlInputSchema;
+        output: typeof ChannelConversationSchema;
+    };
+    /**
+     * Hand a conversation back to the agent, restoring automatic replies.
+     *
+     * The agent re-enters with the conversation context it missed while the
+     * human held control.
+     *
+     * @internal
+     * channel-conversations DD-007: CAS WHERE control='human'; any holder
+     * of can_participate may hand back, not only the takeover holder (v1
+     * single attention pool). Handback never touches the attention flag
+     * (DD-002 D-a #4). The missed-context digest is composed lazily at the
+     * next turn from the agent_witnessed_through watermark, not here.
+     *
+     * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.handBack
+     */
+    handBack: {
+        methodKind: "unary";
+        input: typeof ConversationControlInputSchema;
+        output: typeof ChannelConversationSchema;
+    };
+    /**
+     * Clear a conversation's needs-attention flag without taking it over.
+     *
+     * The false-alarm dismissal: an escalation that needs no reply is
+     * cleared in place, never via a take-over-and-hand-back dance.
+     *
+     * @internal
+     * channel-conversations DD-008 D-f. Control is untouched; the clear is
+     * recorded on the conversation's event history through the
+     * participation writer.
+     *
+     * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.clearAttention
+     */
+    clearAttention: {
+        methodKind: "unary";
+        input: typeof ConversationControlInputSchema;
+        output: typeof ChannelConversationSchema;
+    };
+    /**
+     * Flag this conversation for human attention.
+     *
+     * Non-blocking: the agent keeps serving while the flag summons humans.
+     * Repeated escalation is harmless; the latest reason wins.
+     *
+     * @internal
+     * channel-conversations DD-008: agent-audience only — session-bound
+     * sandbox tokens; the conversation identity derives server-side from
+     * the session's channel labels (never caller-supplied, the DD-003
+     * identity doctrine), so the input carries only the reason. Appends an
+     * internal-lane escalation event and updates the row projection through
+     * the participation writer, idempotently. Approval-free by construction
+     * (unattended surfaces skip gated tools — a gated escalation would
+     * never fire). Cloud-first runtime; OSS refuses FAILED_PRECONDITION.
+     *
+     * @generated from rpc ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController.escalate
+     */
+    escalate: {
+        methodKind: "unary";
+        input: typeof EscalateConversationInputSchema;
+        output: typeof ChannelConversationSchema;
+    };
+}>;

package/ai/stigmer/agentic/agentchannel/v1/conversation_command_pb.js

@@ -0,0 +1,34 @@
+// @generated by protoc-gen-es v2.2.2 with parameter "target=ts,import_extension=js"
+// @generated from file ai/stigmer/agentic/agentchannel/v1/conversation_command.proto (package ai.stigmer.agentic.agentchannel.v1, syntax proto3)
+/* eslint-disable */
+import { fileDesc, serviceDesc } from "@bufbuild/protobuf/codegenv1";
+import { file_ai_stigmer_agentic_agentchannel_v1_conversation_io } from "./conversation_io_pb.js";
+import { file_ai_stigmer_agentic_agentchannel_v1_message_io } from "./message_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/agentchannel/v1/conversation_command.proto.
+ */
+export const file_ai_stigmer_agentic_agentchannel_v1_conversation_command = /*@__PURE__*/ fileDesc("Cj1haS9zdGlnbWVyL2FnZW50aWMvYWdlbnRjaGFubmVsL3YxL2NvbnZlcnNhdGlvbl9jb21tYW5kLnByb3RvEiJhaS5zdGlnbWVyLmFnZW50aWMuYWdlbnRjaGFubmVsLnYxMrcICiRDaGFubmVsQ29udmVyc2F0aW9uQ29tbWFuZENvbnRyb2xsZXIS3QEKBXJlcGx5EjwuYWkuc3RpZ21lci5hZ2VudGljLmFnZW50Y2hhbm5lbC52MS5SZXBseVRvQ29udmVyc2F0aW9uSW5wdXQaPC5haS5zdGlnbWVyLmFnZW50aWMuYWdlbnRjaGFubmVsLnYxLlNlbmRDaGFubmVsTWVzc2FnZU91dHB1dCJYwrgYVAgkEC8iEGFnZW50X2NoYW5uZWxfaWQqPHVuYXV0aG9yaXplZCB0byBwYXJ0aWNpcGF0ZSBpbiBjb252ZXJzYXRpb25zIG9uIHRoaXMgY2hhbm5lbBLbAQoIdGFrZU92ZXISPC5haS5zdGlnbWVyLmFnZW50aWMuYWdlbnRjaGFubmVsLnYxLkNvbnZlcnNhdGlvbkNvbnRyb2xJbnB1dBo3LmFpLnN0aWdtZXIuYWdlbnRpYy5hZ2VudGNoYW5uZWwudjEuQ2hhbm5lbENvbnZlcnNhdGlvbiJYwrgYVAgkEC8iEGFnZW50X2NoYW5uZWxfaWQqPHVuYXV0aG9yaXplZCB0byBwYXJ0aWNpcGF0ZSBpbiBjb252ZXJzYXRpb25zIG9uIHRoaXMgY2hhbm5lbBLbAQoIaGFuZEJhY2sSPC5haS5zdGlnbWVyLmFnZW50aWMuYWdlbnRjaGFubmVsLnYxLkNvbnZlcnNhdGlvbkNvbnRyb2xJbnB1dBo3LmFpLnN0aWdtZXIuYWdlbnRpYy5hZ2VudGNoYW5uZWwudjEuQ2hhbm5lbENvbnZlcnNhdGlvbiJYwrgYVAgkEC8iEGFnZW50X2NoYW5uZWxfaWQqPHVuYXV0aG9yaXplZCB0byBwYXJ0aWNpcGF0ZSBpbiBjb252ZXJzYXRpb25zIG9uIHRoaXMgY2hhbm5lbBLhAQoOY2xlYXJBdHRlbnRpb24SPC5haS5zdGlnbWVyLmFnZW50aWMuYWdlbnRjaGFubmVsLnYxLkNvbnZlcnNhdGlvbkNvbnRyb2xJbnB1dBo3LmFpLnN0aWdtZXIuYWdlbnRpYy5hZ2VudGNoYW5uZWwudjEuQ2hhbm5lbENvbnZlcnNhdGlvbiJYwrgYVAgkEC8iEGFnZW50X2NoYW5uZWxfaWQqPHVuYXV0aG9yaXplZCB0byBwYXJ0aWNpcGF0ZSBpbiBjb252ZXJzYXRpb25zIG9uIHRoaXMgY2hhbm5lbBKIAQoIZXNjYWxhdGUSPS5haS5zdGlnbWVyLmFnZW50aWMuYWdlbnRjaGFubmVsLnYxLkVzY2FsYXRlQ29udmVyc2F0aW9uSW5wdXQaNy5haS5zdGlnbWVyLmFnZW50aWMuYWdlbnRjaGFubmVsLnYxLkNoYW5uZWxDb252ZXJzYXRpb24iBNC4GAEaBKD/Ky9iBnByb3RvMw", [file_ai_stigmer_agentic_agentchannel_v1_conversation_io, file_ai_stigmer_agentic_agentchannel_v1_message_io, file_ai_stigmer_commons_apiresource_rpc_service_options, file_ai_stigmer_commons_rpc_method_options]);
+/**
+ * ChannelConversationCommandController operates a conversation's
+ * participation state: staff replies, takeover and handback of the control
+ * token, attention management, and the agent's escalation ingest.
+ *
+ * @internal
+ * channel-conversations DD-003 D-f (takeOver/handBack), DD-008 D-d
+ * (escalate), DD-009 D-a (reply), DD-010 D-b (the permission map). Two
+ * audiences on one controller, split per method: the four human-facing
+ * commands authorize declaratively on the channel with can_participate
+ * (participants are org humans who may speak to the channel's customers
+ * as the business — NOT channel configurators); escalate is agent-audience
+ * only, session-bound, with identity derived server-side. Every state
+ * transition funnels through the single participation writer (DD-003 D-c)
+ * — CAS-guarded, one winner under concurrent takeover. Cloud-first
+ * runtime: the OSS edition refuses every command FAILED_PRECONDITION (the
+ * sendMessage posture). Never hangs, never lies.
+ *
+ * @generated from service ai.stigmer.agentic.agentchannel.v1.ChannelConversationCommandController
+ */
+export const ChannelConversationCommandController = /*@__PURE__*/ serviceDesc(file_ai_stigmer_agentic_agentchannel_v1_conversation_command, 0);
+//# sourceMappingURL=conversation_command_pb.js.map

package/ai/stigmer/agentic/agentchannel/v1/conversation_command_pb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"conversation_command_pb.js","sourceRoot":"","sources":["../../../../../../ai/stigmer/agentic/agentchannel/v1/conversation_command_pb.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,iJAAiJ;AACjJ,oBAAoB;AAGpB,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,uDAAuD,EAAE,MAAM,yBAAyB,CAAC;AAElG,OAAO,EAAE,kDAAkD,EAAE,MAAM,oBAAoB,CAAC;AACxF,OAAO,EAAE,uDAAuD,EAAE,MAAM,wDAAwD,CAAC;AACjI,OAAO,EAAE,0CAA0C,EAAE,MAAM,2CAA2C,CAAC;AAEvG;;GAEG;AACH,MAAM,CAAC,MAAM,4DAA4D,GAAY,aAAa,CAChG,QAAQ,CAAC,ojDAAojD,EAAE,CAAC,uDAAuD,EAAE,kDAAkD,EAAE,uDAAuD,EAAE,0CAA0C,CAAC,CAAC,CAAC;AAErxD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAgH5C,aAAa,CAChB,WAAW,CAAC,4DAA4D,EAAE,CAAC,CAAC,CAAC"}