@linkedclaw/cli 0.1.1 → 0.1.2

package/dist/bin.js

@@ -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);
       }
@@ -4583,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;
           }
@@ -4630,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);
@@ -4977,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) => {
@@ -5036,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) => {
@@ -5067,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,
@@ -5075,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 } : {}
   };
 }
@@ -5124,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;
@@ -5184,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");
@@ -5198,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 });
@@ -5239,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);
@@ -5268,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