@linkedclaw/cli 0.1.0 → 0.1.2

package/dist/bin.js

@@ -3878,7 +3878,7 @@ function withTimeout(p, ms, code) {
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var LinkedClawError, NetworkError, ApiError, ConfigError, HandlerError, CloudClient, RequesterFlows, TOOL_CALL_PATTERNS, SYSTEM_PATTERNS, DEFAULT_OUTPUT_PATTERNS, DEFAULT_STRIP_PATTERNS, DEFAULT_CLOUD_URL, DEFAULT_RELAY_URL, MessageType, RelayClient, nodeWsConnector, DEFAULT_INVOKE_TIMEOUT_MS, DEFAULT_SESSION_TURN_TIMEOUT_MS, DEFAULT_BROADCAST_OFFER_TIMEOUT_MS, DEFAULT_BROADCAST_EXECUTE_TIMEOUT_MS, BROADCAST_SUBMIT_MAX_RETRIES, BROADCAST_SUBMIT_BASE_MS, BROADCAST_SUBMIT_CAP_MS, ProviderRuntime, CORE_VERSION;
+var LinkedClawError, NetworkError, ApiError, ConfigError, HandlerError, CloudClient, RequesterFlows, TOOL_CALL_PATTERNS, SYSTEM_PATTERNS, DEFAULT_OUTPUT_PATTERNS, DEFAULT_STRIP_PATTERNS, DEFAULT_CLOUD_URL, DEFAULT_RELAY_URL, MessageType, DEFAULT_AUTH_FAILURE_CODES, RelayClient, nodeWsConnector, DEFAULT_INVOKE_TIMEOUT_MS, DEFAULT_SESSION_TURN_TIMEOUT_MS, DEFAULT_BROADCAST_OFFER_TIMEOUT_MS, DEFAULT_BROADCAST_EXECUTE_TIMEOUT_MS, BROADCAST_SUBMIT_MAX_RETRIES, BROADCAST_SUBMIT_BASE_MS, BROADCAST_SUBMIT_CAP_MS, ProviderRuntime, CORE_VERSION;
 var init_dist = __esm({
   "../core/dist/index.js"() {
     "use strict";
@@ -3953,14 +3953,16 @@ var init_dist = __esm({
       };
       // --- Agents ---------------------------------------------------------
       agents = {
+        /**
+         * Server's `GET /api/v1/agents` accepts `capability`, `owner`, `status`,
+         * `sort`. It does NOT paginate via `limit`/`offset` — if you need that,
+         * filter client-side after fetching.
+         */
         search: (query) => this.request("/api/v1/agents", { query }),
         get: (agentId) => this.request(`/api/v1/agents/${encodeURIComponent(agentId)}`),
-        create: (body) => this.request("/api/v1/agents", { method: "PUT", body }).catch(() => this.request("/api/v1/agents", { method: "POST", body })),
-        // ^ Server uses PUT /agents/{id} for update, POST /agents for create on some builds;
-        //   prefer POST for first-create. The .catch here is defensive, not load-bearing.
-        //   See agents_service.py for exact verb wiring.
+        create: (body) => this.request("/api/v1/agents", { method: "POST", body }),
         update: (agentId, body) => this.request(`/api/v1/agents/${encodeURIComponent(agentId)}`, {
-          method: "PATCH",
+          method: "PUT",
           body
         }),
         delete: (agentId) => this.request(`/api/v1/agents/${encodeURIComponent(agentId)}`, { method: "DELETE" }),
@@ -3970,27 +3972,42 @@ var init_dist = __esm({
       sessions = {
         list: (query) => this.request("/api/v1/sessions", { query }),
         get: (sessionId) => this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}`),
-        events: (sessionId) => this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/events`),
+        /**
+         * Server returns `{ events: [...], next_offset: N }`, not a bare array.
+         * Supports `offset` / `limit` query params (default 0 / 100; limit clamped to [1, 1000]).
+         * The events' `seq` field is renamed to `event_seq` in the response.
+         */
+        events: (sessionId, query) => this.request(
+          `/api/v1/sessions/${encodeURIComponent(sessionId)}/events`,
+          { query }
+        ),
         create: (body) => this.request("/api/v1/sessions", { method: "POST", body }),
         activate: (sessionId) => this.request(
           `/api/v1/sessions/${encodeURIComponent(sessionId)}/activate`,
           { method: "POST" }
         ),
-        sendMessage: (sessionId, payload, seq) => this.request(
-          `/api/v1/sessions/${encodeURIComponent(sessionId)}/messages`,
-          { method: "POST", body: { payload, seq } }
-        ),
-        end: (sessionId, messageCount) => this.request(
+        /**
+         * Send a message in an open session.
+         *
+         * Server requires:
+         *   - `seq: int ≥ 1`
+         *   - `payload: dict` (MUST be an object, not a string)
+         *   - JSON size ≤ 64 KiB
+         */
+        sendMessage: (sessionId, payload, seq) => {
+          const body = { seq, payload };
+          return this.request(
+            `/api/v1/sessions/${encodeURIComponent(sessionId)}/messages`,
+            { method: "POST", body }
+          );
+        },
+        end: (sessionId, body) => this.request(
           `/api/v1/sessions/${encodeURIComponent(sessionId)}/end`,
-          {
-            method: "POST",
-            body: messageCount !== void 0 ? { message_count: messageCount } : void 0
-          }
-        ),
-        resume: (sessionId) => this.request(
-          `/api/v1/sessions/${encodeURIComponent(sessionId)}/resume`,
-          { method: "POST" }
+          { method: "POST", body: body ?? {} }
         ),
+        resume: (sessionId) => this.request(`/api/v1/sessions/${encodeURIComponent(sessionId)}/resume`, {
+          method: "POST"
+        }),
         flag: (sessionId) => this.request(
           `/api/v1/sessions/${encodeURIComponent(sessionId)}/flag`,
           { method: "POST" }
@@ -4006,13 +4023,23 @@ var init_dist = __esm({
       // --- Broadcasts -----------------------------------------------------
       broadcasts = {
         list: (query) => this.request("/api/v1/broadcasts", { query }),
-        available: (query) => this.request("/api/v1/broadcasts/available", { query }),
+        available: () => this.request("/api/v1/broadcasts/available"),
         get: (taskId) => this.request(`/api/v1/broadcasts/${encodeURIComponent(taskId)}`),
         create: (body) => this.request("/api/v1/broadcasts", { method: "POST", body }),
+        /**
+         * Accept a broadcast task. Server's `AcceptBroadcastRequest` requires
+         * `agent_id` — the provider must declare which of their agents is accepting.
+         */
         accept: (taskId, body) => this.request(
           `/api/v1/broadcasts/${encodeURIComponent(taskId)}/accept`,
-          { method: "POST", body: body ?? {} }
+          { method: "POST", body }
         ),
+        /**
+         * Submit a broadcast result. Server's `SubmitBroadcastRequest`:
+         *   - `result_data: str` — required (free-text summary)
+         *   - `result_payload: dict | null` — optional structured payload (≤64 KiB)
+         *   - `proof: ProofItem[] | null` — optional evidence
+         */
         submit: (taskId, body) => this.request(
           `/api/v1/broadcasts/${encodeURIComponent(taskId)}/submit`,
           { method: "POST", body }
@@ -4053,16 +4080,19 @@ var init_dist = __esm({
       search(capability, extra) {
         return this.cloud.agents.search({ capability, ...extra });
       }
+      /**
+       * Create a session against a provider agent. The server field is
+       * `provider_agent_id` (not `agent_id`). Escrow is computed server-side as
+       * `listing.price_credits × max_messages` — no `max_credits` body field.
+       * Manifests are attached at invoke/message time, not at session create.
+       */
       async hire(params) {
         const req = {
-          agent_id: params.agentId,
+          provider_agent_id: params.providerAgentId,
           capability: params.capability
         };
         if (params.maxMessages !== void 0) req.max_messages = params.maxMessages;
-        if (params.maxCredits !== void 0) req.max_credits = params.maxCredits;
         if (params.referredBy !== void 0) req.referred_by = params.referredBy;
-        if (params.manifestId !== void 0) req.manifest_id = params.manifestId;
-        if (params.manifest !== void 0) req.manifest = params.manifest;
         const session = await this.cloud.sessions.create(req);
         if (params.autoActivate === false) {
           return { session };
@@ -4070,11 +4100,19 @@ var init_dist = __esm({
         const activation = await this.cloud.sessions.activate(session.session_id);
         return { session: activation, activation };
       }
+      /**
+       * Send a message in an active session.
+       *
+       * Server requires `seq: int ≥ 1` and `payload: dict`. If the caller passes
+       * a plain string we wrap it as `{ text: <string> }` so the server accepts
+       * it — common shape for the default `coding`/`assistant` capabilities.
+       */
       send(sessionId, payload, seq) {
-        return this.cloud.sessions.sendMessage(sessionId, payload, seq);
+        const normalized = typeof payload === "string" ? { text: payload } : payload;
+        return this.cloud.sessions.sendMessage(sessionId, normalized, seq);
       }
-      end(sessionId, messageCount) {
-        return this.cloud.sessions.end(sessionId, messageCount);
+      end(sessionId, body) {
+        return this.cloud.sessions.end(sessionId, body);
       }
       invoke(agentId, body) {
         return this.cloud.invokes.call(agentId, body);
@@ -4088,9 +4126,11 @@ var init_dist = __esm({
       listBroadcasts(query) {
         return this.cloud.broadcasts.list(query);
       }
-      acceptBroadcast(taskId, slotKey) {
-        return this.cloud.broadcasts.accept(taskId, slotKey !== void 0 ? { slot_key: slotKey } : void 0);
+      /** Provider-side helper: accept a broadcast slot (requires `agent_id`). */
+      acceptBroadcast(taskId, body) {
+        return this.cloud.broadcasts.accept(taskId, body);
       }
+      /** Provider-side helper: submit a broadcast result. */
       submitBroadcast(taskId, body) {
         return this.cloud.broadcasts.submit(taskId, body);
       }
@@ -4144,6 +4184,10 @@ var init_dist = __esm({
       INVOKE: "invoke",
       INVOKE_RESULT: "invoke_result"
     };
+    DEFAULT_AUTH_FAILURE_CODES = Object.freeze([
+      1008,
+      ...Array.from({ length: 99 }, (_, i) => 4001 + i)
+    ]);
     RelayClient = class extends EventEmitter {
       url;
       agentId;
@@ -4152,11 +4196,15 @@ var init_dist = __esm({
       heartbeatMs;
       reconnectBaseMs;
       reconnectMaxMs;
+      authGraceMs;
+      authFailureCloseCodes;
       connector;
       transport;
       heartbeatTimer;
+      authGraceTimer;
       stopped = false;
       reconnectAttempt = 0;
+      fatalState = null;
       constructor(opts) {
         super();
         this.url = opts.url;
@@ -4166,8 +4214,16 @@ var init_dist = __esm({
         this.heartbeatMs = opts.heartbeatMs ?? 3e4;
         this.reconnectBaseMs = opts.reconnectBaseMs ?? 1e3;
         this.reconnectMaxMs = opts.reconnectMaxMs ?? 3e4;
+        this.authGraceMs = opts.authGraceMs ?? 5e3;
+        this.authFailureCloseCodes = new Set(
+          opts.authFailureCloseCodes ?? DEFAULT_AUTH_FAILURE_CODES
+        );
         this.connector = opts.connector ?? nodeWsConnector;
       }
+      /** Last detected permanent-auth-failure, or null when OK / still retrying. */
+      getFatal() {
+        return this.fatalState;
+      }
       on(event, listener) {
         return super.on(event, listener);
       }
@@ -4183,13 +4239,15 @@ var init_dist = __esm({
           const { transport, ready } = await this.connector(this.url);
           this.transport = transport;
           transport.addMessageListener((data) => this.handleFrame(data));
-          transport.addCloseListener((code, reason) => this.handleClose(`close ${code}: ${reason}`));
-          transport.addErrorListener((err) => this.handleClose(`error: ${err.message}`));
+          transport.addCloseListener(
+            (code, reason) => this.handleClose(code, `close ${code}: ${reason}`)
+          );
+          transport.addErrorListener((err) => this.handleClose(null, `error: ${err.message}`));
           await ready;
           await this.sendIdentify();
           this.startHeartbeat();
-          this.reconnectAttempt = 0;
           this.emit("connected");
+          this.startAuthGraceTimer();
         } catch (err) {
           throw new NetworkError(`relay connect failed: ${err.message}`, err);
         }
@@ -4201,6 +4259,7 @@ var init_dist = __esm({
       async stop() {
         this.stopped = true;
         this.stopHeartbeat();
+        this.cancelAuthGraceTimer();
         if (this.transport) {
           try {
             await this.transport.close(1e3, "client_stop");
@@ -4248,11 +4307,39 @@ var init_dist = __esm({
         const evt = parseInbound(frame);
         if (evt) this.emit("event", evt);
       }
-      handleClose(reason) {
+      handleClose(code, reason) {
         this.stopHeartbeat();
+        this.cancelAuthGraceTimer();
         this.transport = void 0;
         this.emit("disconnected", reason);
-        if (!this.stopped) void this.scheduleReconnect();
+        if (this.stopped) return;
+        if (code !== null && this.authFailureCloseCodes.has(code)) {
+          this.stopped = true;
+          this.fatalState = { reason, code };
+          this.emit("fatal", { reason, code });
+          return;
+        }
+        void this.scheduleReconnect();
+      }
+      startAuthGraceTimer() {
+        this.cancelAuthGraceTimer();
+        if (this.authGraceMs <= 0) {
+          this.reconnectAttempt = 0;
+          return;
+        }
+        this.authGraceTimer = setTimeout(() => {
+          this.authGraceTimer = void 0;
+          if (this.transport) this.reconnectAttempt = 0;
+        }, this.authGraceMs);
+        if (typeof this.authGraceTimer.unref === "function") {
+          this.authGraceTimer.unref();
+        }
+      }
+      cancelAuthGraceTimer() {
+        if (this.authGraceTimer) {
+          clearTimeout(this.authGraceTimer);
+          this.authGraceTimer = void 0;
+        }
       }
       async scheduleReconnect() {
         this.reconnectAttempt += 1;
@@ -4320,6 +4407,7 @@ var init_dist = __esm({
       inFlightBroadcasts = /* @__PURE__ */ new Set();
       running = false;
       connected = false;
+      fatal = null;
       constructor(deps) {
         this.cloud = deps.cloud;
         this.relay = deps.relay;
@@ -4331,10 +4419,18 @@ var init_dist = __esm({
         this.running = true;
         this.relay.on("connected", () => {
           this.connected = true;
+          this.fatal = null;
         });
         this.relay.on("disconnected", () => {
           this.connected = false;
         });
+        this.relay.on("fatal", (info) => {
+          this.fatal = info;
+          this.connected = false;
+          console.error(
+            `linkedclaw: relay rejected our credentials (code=${info.code ?? "?"}: ${info.reason}). Not retrying. Check apiKey/agentId and restart the plugin.`
+          );
+        });
         this.relay.on("event", (evt) => {
           void this.dispatch(evt);
         });
@@ -4351,7 +4447,8 @@ var init_dist = __esm({
           activeSessions: this.activeSessions.size,
           inFlightInvokes: this.inFlightInvokes.size,
           inFlightBroadcasts: this.inFlightBroadcasts.size,
-          ...this.config.agentId !== void 0 ? { agentId: this.config.agentId } : {}
+          ...this.config.agentId !== void 0 ? { agentId: this.config.agentId } : {},
+          ...this.fatal !== null ? { fatal: this.fatal } : {}
         };
       }
       // ────────── dispatch ──────────
@@ -4526,11 +4623,12 @@ var init_dist = __esm({
         try {
           const decision = await this.runOffer(offer);
           if (!decision || !decision.accept) return;
+          const acceptBody = {
+            agent_id: this.config.agentId ?? ""
+          };
+          if (decision.slot_key !== void 0) acceptBody.slot_key = decision.slot_key;
           try {
-            await this.cloud.broadcasts.accept(
-              offer.task_id,
-              decision.slot_key !== void 0 ? { slot_key: decision.slot_key } : void 0
-            );
+            await this.cloud.broadcasts.accept(offer.task_id, acceptBody);
           } catch {
             return;
           }
@@ -4573,13 +4671,16 @@ var init_dist = __esm({
           return null;
         }
       }
-      async submitWithRetry(taskId, result, slotKey) {
+      async submitWithRetry(taskId, result, _slotKey) {
+        const payload = this.sanitizeOut(result.result_payload ?? {});
+        const resultData = typeof result.result_data === "string" && result.result_data.length > 0 ? result.result_data : JSON.stringify(payload);
         const body = {
-          output: this.sanitizeOut(result.result_payload ?? {}),
-          ...result.quality_self_report !== void 0 ? { quality_self_report: result.quality_self_report } : {},
-          ...slotKey !== void 0 ? { slot_key: slotKey } : {},
-          ...result.proof !== void 0 ? { evidence: result.proof } : {}
+          result_data: resultData,
+          result_payload: payload
         };
+        if (Array.isArray(result.proof)) {
+          body.proof = result.proof;
+        }
         for (let attempt = 0; attempt < BROADCAST_SUBMIT_MAX_RETRIES; attempt += 1) {
           try {
             await this.cloud.broadcasts.submit(taskId, body);
@@ -4920,9 +5021,8 @@ function registerProviderCommands(program2) {
   });
   provider.command("listings").description("Show my own agent listings (as provider)").option("--human", "Human-readable output").action(async (opts) => {
     await runCommand(async () => {
-      const { cloud, config } = buildContext();
-      const all = await cloud.agents.search({});
-      return all.filter((a) => a.owner_id === (config.agentId ? void 0 : void 0) || true);
+      const { cloud } = buildContext();
+      return cloud.agents.search({ owner: "me" });
     }, { human: opts.human });
   });
   provider.command("run <config>").description("Run a provider daemon: connect WS, dispatch events to handler subprocess").option("--handler-cmd <cmd>", "Shell command to spawn as the handler child process").option("--handler-http <url>", "HTTP webhook URL to POST each event to (alternative to --handler-cmd)").option("--human", "Human-readable status output").action(async (path, opts) => {
@@ -4979,10 +5079,12 @@ function registerProviderCommands(program2) {
     await new Promise(() => {
     });
   });
-  provider.command("pick <bct_id>").description("Manually accept a broadcast task (provider side)").option("--slot-key <key>", "Slot key for sliced broadcasts").option("--human", "Human-readable output").action(async (taskId, opts) => {
+  provider.command("pick <bct_id>").description("Manually accept a broadcast task (provider side)").requiredOption("--agent-id <agt_id>", "Which of your agents is accepting").option("--slot-key <key>", "Slot key for sliced broadcasts").option("--human", "Human-readable output").action(async (taskId, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
-      return flows.acceptBroadcast(taskId, opts.slotKey);
+      const body = { agent_id: opts.agentId };
+      if (opts.slotKey !== void 0) body.slot_key = opts.slotKey;
+      return flows.acceptBroadcast(taskId, body);
     }, { human: opts.human });
   });
   provider.command("submit <bct_id> <result_file>").description('Submit a broadcast result. result_file = JSON path or "-" for stdin.').option("--human", "Human-readable output").action(async (taskId, resultFile, opts) => {
@@ -5010,7 +5112,6 @@ function buildCreateAgentRequest(cfg) {
   }
   if (!cfg.pricingModel) throw new Error("provider config missing `pricingModel`");
   if (cfg.priceCredits === void 0) throw new Error("provider config missing `priceCredits`");
-  if (!cfg.providerType) throw new Error("provider config missing `providerType`");
   return {
     slug: cfg.slug,
     name: cfg.agentName,
@@ -5018,7 +5119,6 @@ function buildCreateAgentRequest(cfg) {
     capabilities: cfg.capabilities,
     pricing_model: cfg.pricingModel,
     price_credits: cfg.priceCredits,
-    provider_type: cfg.providerType,
     ...cfg.verifyMethod ? { verify_method: cfg.verifyMethod } : {}
   };
 }
@@ -5067,56 +5167,64 @@ import { readFileSync as readFileSync3 } from "fs";
 import { load as yamlLoad3 } from "js-yaml";
 init_output();
 function registerRequesterCommands(program2) {
-  program2.command("search <capability>").description("Search public agent listings by capability").option("--topology <t>", "invoke | session | one_to_many | broadcast").option("--limit <n>", "Max results", (v) => parseInt(v, 10)).option("--human", "Human-readable output").action(async (capability, opts) => {
+  program2.command("search <capability>").description("Search public agent listings by capability").option("--owner <owner>", '"me" or a "usr_..." id').option("--status <status>", "filter by status (online/offline/disabled)").option("--sort <sort>", "newest | price_asc | price_desc | trust").option("--human", "Human-readable output").action(async (capability, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
       return flows.search(capability, {
-        ...opts.topology ? { topology: opts.topology } : {},
-        ...opts.limit ? { limit: opts.limit } : {}
+        ...opts.owner ? { owner: opts.owner } : {},
+        ...opts.status ? { status: opts.status } : {},
+        ...opts.sort ? { sort: opts.sort } : {}
       });
     }, { human: opts.human });
   });
-  program2.command("hire <agent_id>").description("Create and activate a 1:1 session with an agent").requiredOption("--capability <cap>", "Capability being hired").option("--max-messages <n>", "Message cap", (v) => parseInt(v, 10)).option("--max-credits <n>", "Credit cap", (v) => parseInt(v, 10)).option("--referred-by <ref_id>", "Attribution: referrer agent id").option("--manifest-id <mft_id>", "Pre-registered task manifest id").option(
-    "--manifest <json>",
-    'Inline task manifest JSON (literal, @file, or "-" for stdin). Minimum: {"intention":"..."}'
-  ).option("--no-activate", "Create session but do not activate (returns session only)").option("--human", "Human-readable output").action(async (agentId, opts) => {
+  program2.command("hire <agent_id>").description("Create and activate a 1:1 session with an agent").requiredOption("--capability <cap>", "Capability being hired").option("--max-messages <n>", "Message cap (server default 1)", (v) => parseInt(v, 10)).option("--referred-by <ref_id>", "Attribution: referrer agent id").option("--no-activate", "Create session but do not activate (returns session only)").option("--human", "Human-readable output").action(async (agentId, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
-      const manifest = await resolveManifestOpt(opts.manifest, opts.manifestId);
       return flows.hire({
-        agentId,
+        providerAgentId: agentId,
         capability: opts.capability,
         ...opts.maxMessages !== void 0 ? { maxMessages: opts.maxMessages } : {},
-        ...opts.maxCredits !== void 0 ? { maxCredits: opts.maxCredits } : {},
         ...opts.referredBy !== void 0 ? { referredBy: opts.referredBy } : {},
-        ...opts.manifestId !== void 0 ? { manifestId: opts.manifestId } : {},
-        ...manifest !== void 0 ? { manifest } : {},
         autoActivate: opts.activate !== false
       });
     }, { human: opts.human });
   });
-  program2.command("send <session_id> <message>").description('Send a message in an active session. Use "-" to read from stdin.').option("--seq <n>", "Client-side sequence number", (v) => parseInt(v, 10)).option("--human", "Human-readable output").action(async (sessionId, message, opts) => {
+  program2.command("send <session_id> <message>").description(
+    `Send a message in an active session. Message is wrapped as {"text": "..."} if it's a plain string, or passed through if it's a JSON object. Use "-" to read from stdin.`
+  ).requiredOption("--seq <n>", "Sequence number (server requires \u2265 1)", (v) => parseInt(v, 10)).option("--json", "Interpret message as a JSON object literal (default: wrap as {text})").option("--human", "Human-readable output").action(async (sessionId, message, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
-      const payload = message === "-" ? await readStdin() : message;
+      const raw = message === "-" ? await readStdin() : message;
+      const payload = opts.json ? parseJsonOrFail(raw, "<message>") : raw;
       return flows.send(sessionId, payload, opts.seq);
     }, { human: opts.human });
   });
-  program2.command("end <session_id>").description("Mark a session ended").option("--message-count <n>", "Declare final message count", (v) => parseInt(v, 10)).option("--human", "Human-readable output").action(async (sessionId, opts) => {
+  program2.command("end <session_id>").description("Mark a session ended").option("--message-count <n>", "Declare final message count", (v) => parseInt(v, 10)).option("--final-output <text>", "Final output blurb (optional)").option("--human", "Human-readable output").action(async (sessionId, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
-      return flows.end(sessionId, opts.messageCount);
+      const body = {};
+      if (opts.messageCount !== void 0) body.message_count = opts.messageCount;
+      if (opts.finalOutput !== void 0) body.final_output = opts.finalOutput;
+      return flows.end(sessionId, body);
     }, { human: opts.human });
   });
-  program2.command("invoke <agent_id>").description("One-shot stateless invoke").requiredOption("--capability <cap>", "Capability").requiredOption("--input <json>", 'JSON input (or "-" to read from stdin)').option("--max-credits <n>", "Max credits", (v) => parseInt(v, 10)).option("--timeout <s>", "Server-side timeout seconds", (v) => parseInt(v, 10)).option("--referred-by <ref_id>", "Attribution: referrer agent id").option("--manifest-id <mft_id>", "Pre-registered task manifest id").option(
+  program2.command("invoke <agent_id>").description("One-shot stateless invoke").requiredOption("--capability <cap>", "Capability").requiredOption("--input <json>", 'JSON input (or "-" to read from stdin)').option("--max-credits <n>", "Max credits", (v) => parseInt(v, 10)).option("--timeout <s>", "Server-side timeout seconds (5..300, default 60)", (v) => parseInt(v, 10)).option("--referred-by <ref_id>", "Attribution: referrer agent id").option("--manifest-id <mft_id>", "Pre-registered task manifest id").option(
     "--manifest <json>",
     'Inline task manifest JSON (literal, @file, or "-" for stdin). Minimum: {"intention":"..."}'
+  ).option(
+    "--intention <text>",
+    "Shortcut: builds a minimal manifest {intention: <text>} if --manifest/--manifest-id are not set."
   ).option("--human", "Human-readable output").action(async (agentId, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
       const inputJson = opts.input === "-" ? await readStdin() : opts.input;
       const input = parseJsonOrFail(inputJson, "--input");
-      const manifest = await resolveManifestOpt(opts.manifest, opts.manifestId);
+      const manifest = await resolveManifestOpt(
+        opts.manifest,
+        opts.manifestId,
+        opts.intention,
+        `invoke: ${opts.capability}`
+      );
       const body = { capability: opts.capability, input };
       if (opts.maxCredits !== void 0) body.max_credits = opts.maxCredits;
       if (opts.timeout !== void 0) body.timeout_seconds = opts.timeout;
@@ -5127,7 +5235,9 @@ function registerRequesterCommands(program2) {
     }, { human: opts.human });
   });
   const broadcast = program2.command("broadcast").description("Broadcast task commands");
-  broadcast.command("create <manifest>").description('Create a broadcast task from a YAML/JSON manifest file. Use "-" for stdin.').option("--human", "Human-readable output").action(async (manifestPath, opts) => {
+  broadcast.command("create <manifest>").description(
+    'Create a broadcast task from a YAML/JSON manifest file. Use "-" for stdin. Required fields: capability, instruction, target_providers, credits_per_provider.'
+  ).option("--human", "Human-readable output").action(async (manifestPath, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
       const raw = manifestPath === "-" ? await readStdin() : readFileSync3(manifestPath, "utf8");
@@ -5141,37 +5251,37 @@ function registerRequesterCommands(program2) {
       return flows.getBroadcast(taskId);
     }, { human: opts.human });
   });
-  broadcast.command("list").description("List broadcasts I own").option("--status <s>", "Filter by status").option("--capability <c>", "Filter by capability").option("--human", "Human-readable output").action(async (opts) => {
+  broadcast.command("list").description("List broadcasts I own").option("--status <s>", "Filter by status").option("--human", "Human-readable output").action(async (opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
       return flows.listBroadcasts({
-        ...opts.status ? { status: opts.status } : {},
-        ...opts.capability ? { capability: opts.capability } : {}
+        ...opts.status ? { status: opts.status } : {}
       });
     }, { human: opts.human });
   });
-  broadcast.command("available").description("List open broadcasts I could pick up (as provider)").option("--capability <c>", "Filter by capability").option("--limit <n>", "Max results", (v) => parseInt(v, 10)).option("--human", "Human-readable output").action(async (opts) => {
+  broadcast.command("available").description("List open broadcasts I could pick up (as provider)").option("--human", "Human-readable output").action(async (opts) => {
     await runCommand(async () => {
       const { cloud } = buildContext();
-      return cloud.broadcasts.available({
-        ...opts.capability ? { capability: opts.capability } : {},
-        ...opts.limit ? { limit: opts.limit } : {}
-      });
+      return cloud.broadcasts.available();
     }, { human: opts.human });
   });
-  broadcast.command("accept <bct_id>").description("Accept a broadcast (provider side) \u2014 returns a result_id").option("--slot-key <key>", "Slot key for sliced broadcasts").option("--human", "Human-readable output").action(async (taskId, opts) => {
+  broadcast.command("accept <bct_id>").description("Accept a broadcast (provider side) \u2014 returns a result_id").requiredOption("--agent-id <agt_id>", "Which of your agents is accepting").option("--slot-key <key>", "Slot key for sliced broadcasts").option("--human", "Human-readable output").action(async (taskId, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
-      return flows.acceptBroadcast(taskId, opts.slotKey);
+      const body = { agent_id: opts.agentId };
+      if (opts.slotKey !== void 0) body.slot_key = opts.slotKey;
+      return flows.acceptBroadcast(taskId, body);
     }, { human: opts.human });
   });
-  broadcast.command("submit <bct_id>").description("Submit broadcast result (provider side). Body = JSON file or stdin.").requiredOption("--body <json>", 'JSON body (or "-" to read from stdin)').option("--human", "Human-readable output").action(async (taskId, opts) => {
+  broadcast.command("submit <bct_id>").description(
+    "Submit broadcast result (provider side). Body must include `result_data` (string) and may include `result_payload` (object) and `proof` (array)."
+  ).requiredOption("--body <json>", 'JSON body (or "-" to read from stdin)').option("--human", "Human-readable output").action(async (taskId, opts) => {
     await runCommand(async () => {
       const { flows } = buildContext();
       const raw = opts.body === "-" ? await readStdin() : readFileSync3(opts.body, "utf8");
       const body = parseJsonOrFail(raw, "--body");
-      if (typeof body !== "object" || body === null || !("output" in body)) {
-        throw new Error("--body must include an `output` object");
+      if (typeof body !== "object" || body === null || typeof body.result_data !== "string") {
+        throw new Error("--body must include a `result_data` string field");
       }
       return flows.submitBroadcast(taskId, body);
     }, { human: opts.human });
@@ -5182,7 +5292,7 @@ function registerRequesterCommands(program2) {
       return cloud.receipts.get(receiptId);
     }, { human: opts.human });
   });
-  program2.command("trust <agent_id>").description("Get trust summary for an agent").option("--human", "Human-readable output").action(async (agentId, opts) => {
+  program2.command("trust <agent_id>").description("Get trust summary for an agent (per-capability)").option("--human", "Human-readable output").action(async (agentId, opts) => {
     await runCommand(async () => {
       const { cloud } = buildContext();
       return cloud.agents.trust(agentId);
@@ -5211,24 +5321,29 @@ function parseYamlOrJson(raw) {
   if (trimmed.startsWith("{") || trimmed.startsWith("[")) return JSON.parse(raw);
   return yamlLoad3(raw);
 }
-async function resolveManifestOpt(manifestOpt, manifestId) {
-  if (manifestOpt === void 0) return void 0;
-  if (manifestId !== void 0) {
+async function resolveManifestOpt(manifestOpt, manifestId, intention, defaultIntention) {
+  if (manifestOpt !== void 0 && manifestId !== void 0) {
     throw new Error("--manifest and --manifest-id are mutually exclusive");
   }
-  let raw;
-  if (manifestOpt === "-") {
-    raw = await readStdin();
-  } else if (manifestOpt.startsWith("@")) {
-    raw = readFileSync3(manifestOpt.slice(1), "utf8");
-  } else {
-    raw = manifestOpt;
+  if (manifestId !== void 0) {
+    return void 0;
   }
-  const parsed = parseJsonOrFail(raw, "--manifest");
-  if (typeof parsed.intention !== "string" || parsed.intention.length === 0) {
-    throw new Error('--manifest must include a non-empty "intention" field');
+  if (manifestOpt !== void 0) {
+    let raw;
+    if (manifestOpt === "-") {
+      raw = await readStdin();
+    } else if (manifestOpt.startsWith("@")) {
+      raw = readFileSync3(manifestOpt.slice(1), "utf8");
+    } else {
+      raw = manifestOpt;
+    }
+    const parsed = parseJsonOrFail(raw, "--manifest");
+    if (typeof parsed.intention !== "string" || parsed.intention.length === 0) {
+      throw new Error('--manifest must include a non-empty "intention" field');
+    }
+    return parsed;
   }
-  return parsed;
+  return { intention: intention ?? defaultIntention };
 }
 
 // src/bin.ts