@koda-sl/baker-cli 0.371.0 → 0.373.0

package/dist/cli.js

@@ -70,7 +70,7 @@ import {
   validateCanvasDeep,
   withoutCastName,
   ytDlpBlockSignal
-} from "./chunk-3NIBJ3GL.js";
+} from "./chunk-FGHMWBUD.js";
 import {
   csvOrJson,
   daysAgoIso,
@@ -80,7 +80,7 @@ import {
   resolveEffectiveStatus,
   statusFilterHints,
   todayIso
-} from "./chunk-L4QXAYIC.js";
+} from "./chunk-4ACU7GBN.js";
 import {
   buildQueryCacheKey,
   cacheGet,
@@ -96,42 +96,50 @@ import {
   writeAdsJson,
   writeAdsOutput,
   writeJsonEnvelope
-} from "./chunk-FXVELNAS.js";
+} from "./chunk-ZI7TPBXB.js";
 import {
   ApiError,
   apiGet,
   apiGetWithHeaders,
   apiPost,
   validateConvexId
-} from "./chunk-MZQC4LII.js";
+} from "./chunk-MF7YA62W.js";
 import {
   installExitRecord,
   installStreamTaps,
   logInvocation
-} from "./chunk-XWHHYHKQ.js";
+} from "./chunk-VZEDAFAR.js";
 import {
   adContentNormalizer,
   captureBudgetMs,
   captureProxyCredentials,
   captureVimeoCookie,
+  commandPathOf,
   compactImage,
   compactVideo,
+  findSchema,
   getEnv,
   hasOpenRouterKey,
+  installFieldMask,
   isProxyFailure,
+  listSchemas,
   openRouterKey,
   optionalChatId,
+  outputFlagForCommand,
   plannedRoutes,
   refuseNonPublicUrl,
+  refuseUnknownFlags,
+  registerSchema,
   requireChatId,
   resolveChatId,
   shouldEscalate,
+  takeFieldsFlag,
   testimonialNormalizer,
   videoNormalizer,
   winningAdNormalizer,
   writeJson,
   writeOutput
-} from "./chunk-2OKSJNLA.js";
+} from "./chunk-HJEMOSPH.js";
 
 // src/cli.ts
 import { defineCommand as defineCommand248, runMain } from "citty";
@@ -172,30 +180,6 @@ import { defineCommand as defineCommand18 } from "citty";
 // src/commands/actions/claim.ts
 import { defineCommand } from "citty";
 
-// src/schemas.ts
-var registry = /* @__PURE__ */ new Map();
-function registerSchema(schema) {
-  registry.set(schema.command, schema);
-}
-function listSchemas() {
-  return [...registry.keys()];
-}
-function spellingKey(name) {
-  return name.toLowerCase().replaceAll("-", "");
-}
-function resolveSchemaName(words2, names) {
-  const joined = words2.join(".");
-  if (names.includes(joined)) {
-    return joined;
-  }
-  const matches = names.filter((name) => spellingKey(name) === spellingKey(joined));
-  return matches.length === 1 ? matches[0] : void 0;
-}
-function findSchema(words2) {
-  const name = resolveSchemaName(words2, listSchemas());
-  return name === void 0 ? void 0 : registry.get(name);
-}
-
 // ../api/src/actions.ts
 import { z } from "zod";
 var actionStatusSchema = z.enum(["pending", "in_progress", "completed", "discarded"]);
@@ -7159,37 +7143,10 @@ function parseConditionsExpression(expression) {
 }
 
 // ../api/src/scheduledAgents.ts
-import { z as z24 } from "zod";
-var scheduledAgentRunsAsSchema = z24.object({
-  /** The person each run acts as; null when nobody owns it, so only the company's tools load. */
-  name: z24.string().nullable(),
-  /** That person's own connected tools. */
-  personalTools: z24.array(z24.string()),
-  /** The company's and organization's tools, and the platforms Baker connects to directly. */
-  companyTools: z24.array(z24.string()),
-  /** Set up, but nobody has signed in to them, so a run gets nothing from them. */
-  notSignedIn: z24.array(z24.string()).optional(),
-  /** The company switched connected tools off: only the platforms load. */
-  toolsOff: z24.literal(true).optional()
-});
-var AUTO_PUBLISH_REFUSAL = 'Publishing every run unreviewed is a standing authorization only the user can grant, on the item itself, so it is recorded against their name. Stage the item without it, and once this chat is published ask the user to switch on "Publish its work on its own" (under "When a run finishes") on the item in Scheduled agents.';
-var scheduledAgentsUnstageRequestSchema = z24.object({
-  chatId: z24.string().min(1),
-  /** The item: a published id or a temp_agent_* id this chat staged. */
-  ref: z24.string().min(1),
-  /** One change of it, by its `index` in `list`'s draft. Left out, every change staged on it. */
-  index: z24.number().int().min(0).optional()
-});
-var scheduledAgentsUnstageResponseSchema = z24.object({
-  ok: z24.literal(true),
-  data: z24.object({ ref: z24.string(), removed: z24.number().int().min(1) })
-});
-
-// ../api/src/scheduledAgentTriggerCatalog.ts
-import { z as z26 } from "zod";
+import { z as z25 } from "zod";
 
 // ../api/src/scheduledAgentTriggers.ts
-import { z as z25 } from "zod";
+import { z as z24 } from "zod";
 var TRIGGER_GROUPS = {
   time: { label: "Time", blurb: "On a clock you set." },
   incoming: { label: "Incoming", blurb: "Another tool or your site calls in." },
@@ -7555,152 +7512,233 @@ var TRIGGER_TARGETS = {
   "review.received": [target("sourceId", { open: false })],
   "advertiser.new_ads": [target("advertiserId", { open: false })]
 };
-var triggerTargetOptionSchema = z25.object({
-  value: z25.string(),
-  label: z25.string(),
+var triggerTargetOptionSchema = z24.object({
+  value: z24.string(),
+  label: z24.string(),
   /** A second line: a status, a tag list, where it comes from. */
-  detail: z25.string().optional(),
+  detail: z24.string().optional(),
   /** A mark: a path under the dashboard's `/logos/`, or an absolute image URL. */
-  logo: z25.string().optional()
+  logo: z24.string().optional()
 });
-var scheduledAgentTriggerSchema = z25.discriminatedUnion("kind", [
-  z25.object({
-    kind: z25.literal("time.once"),
+var scheduledAgentTriggerSchema = z24.discriminatedUnion("kind", [
+  z24.object({
+    kind: z24.literal("time.once"),
     /** Epoch ms. Must still be in the future when the item is written. */
-    runAt: z25.number(),
+    runAt: z24.number(),
     /** IANA zone. Defaults to the company's. */
-    tz: z25.string()
+    tz: z24.string()
   }),
-  z25.object({
-    kind: z25.literal("time.cron"),
+  z24.object({
+    kind: z24.literal("time.cron"),
     /** Five-field cron expression. */
-    cronspec: z25.string(),
-    tz: z25.string()
+    cronspec: z24.string(),
+    tz: z24.string()
   }),
-  z25.object({ kind: z25.literal("webhook.received") }),
-  z25.object({
-    kind: z25.literal("app.event"),
+  z24.object({ kind: z24.literal("webhook.received") }),
+  z24.object({
+    kind: z24.literal("app.event"),
     /** The connected tool, by its toolkit slug: `gmail`, `slack`. */
-    toolkit: z25.string(),
+    toolkit: z24.string(),
     /** What happens in it, by the tool's own trigger id: `GMAIL_NEW_GMAIL_MESSAGE`. */
-    appEvent: z25.string(),
+    appEvent: z24.string(),
     /** Which connected account — a tool can be connected more than once. */
-    account: z25.string(),
+    account: z24.string(),
     /** The tool's own settings for the event (a label, a channel, a repository), as JSON text. */
-    configJson: z25.string().optional()
+    configJson: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("event.received"),
+  z24.object({
+    kind: z24.literal("event.received"),
     /** Absent = any event. */
-    eventName: z25.string().optional()
+    eventName: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("connection.created"),
+  z24.object({
+    kind: z24.literal("connection.created"),
     /** Absent = any tool. An OAuth provider type, or a Composio toolkit slug. */
-    provider: z25.string().optional()
+    provider: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("connection.removed"),
-    provider: z25.string().optional()
+  z24.object({
+    kind: z24.literal("connection.removed"),
+    provider: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("form.submitted"),
+  z24.object({
+    kind: z24.literal("form.submitted"),
     /** Absent = any Form. */
-    flowId: z25.string().optional()
+    flowId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("flow.step.submitted"),
-    flowId: z25.string(),
-    stepId: z25.string()
+  z24.object({
+    kind: z24.literal("flow.step.submitted"),
+    flowId: z24.string(),
+    stepId: z24.string()
   }),
-  z25.object({
-    kind: z25.literal("landing.created"),
+  z24.object({
+    kind: z24.literal("landing.created"),
     /** Absent = any page. A page's slug. */
-    page: z25.string().optional(),
+    page: z24.string().optional(),
     /** Absent = any tag. */
-    tag: z25.string().optional()
+    tag: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("landing.published"),
-    page: z25.string().optional(),
-    tag: z25.string().optional()
+  z24.object({
+    kind: z24.literal("landing.published"),
+    page: z24.string().optional(),
+    tag: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("experiment.started"),
+  z24.object({
+    kind: z24.literal("experiment.started"),
     /** Absent = any test. */
-    experimentId: z25.string().optional()
+    experimentId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("experiment.decided"),
-    experimentId: z25.string().optional()
+  z24.object({
+    kind: z24.literal("experiment.decided"),
+    experimentId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("experiment.ended"),
-    experimentId: z25.string().optional()
+  z24.object({
+    kind: z24.literal("experiment.ended"),
+    experimentId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("experiment.concluded"),
-    experimentId: z25.string().optional()
+  z24.object({
+    kind: z24.literal("experiment.concluded"),
+    experimentId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("task.created"),
+  z24.object({
+    kind: z24.literal("task.created"),
     /** Absent = any Task. */
-    tag: z25.string().optional()
+    tag: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("task.claimed"),
+  z24.object({
+    kind: z24.literal("task.claimed"),
     /** Absent = any Task. One Task, by id. */
-    taskId: z25.string().optional(),
-    tag: z25.string().optional()
+    taskId: z24.string().optional(),
+    tag: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("task.completed"),
-    taskId: z25.string().optional(),
-    tag: z25.string().optional()
+  z24.object({
+    kind: z24.literal("task.completed"),
+    taskId: z24.string().optional(),
+    tag: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("session.published"),
+  z24.object({
+    kind: z24.literal("session.published"),
     /** Absent = any agent. Only the runs of this Scheduled agent. */
-    agentId: z25.string().optional()
+    agentId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("session.publish_failed"),
-    agentId: z25.string().optional()
+  z24.object({
+    kind: z24.literal("session.publish_failed"),
+    agentId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("knowledge.updated"),
+  z24.object({
+    kind: z24.literal("knowledge.updated"),
     /** Absent = any collection. */
-    collection: z25.string().optional()
+    collection: z24.string().optional()
   }),
-  z25.object({ kind: z25.literal("brand.updated") }),
-  z25.object({ kind: z25.literal("creative.created") }),
-  z25.object({
-    kind: z25.literal("connection.needs_reconnect"),
-    provider: z25.string().optional()
+  z24.object({ kind: z24.literal("brand.updated") }),
+  z24.object({ kind: z24.literal("creative.created") }),
+  z24.object({
+    kind: z24.literal("connection.needs_reconnect"),
+    provider: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("session.publish_incomplete"),
+  z24.object({
+    kind: z24.literal("session.publish_incomplete"),
     /** Absent = any platform. One of `PUBLISH_PLATFORMS`. */
-    platform: z25.string().optional(),
-    agentId: z25.string().optional()
+    platform: z24.string().optional(),
+    agentId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("review.received"),
+  z24.object({
+    kind: z24.literal("review.received"),
     /** Absent = any review source. */
-    sourceId: z25.string().optional()
+    sourceId: z24.string().optional()
   }),
-  z25.object({
-    kind: z25.literal("advertiser.new_ads"),
+  z24.object({
+    kind: z24.literal("advertiser.new_ads"),
     /** Absent = any followed advertiser. */
-    advertiserId: z25.string().optional()
+    advertiserId: z24.string().optional()
   })
 ]);
-var occurrencesSchema = z25.array(z25.number().int().positive()).max(32);
+var occurrencesSchema = z24.array(z24.number().int().positive()).max(32);
 function firstTimes(count2) {
   return Array.from({ length: Math.max(0, Math.floor(count2)) }, (_, index) => index + 1);
 }
 
+// ../api/src/scheduledAgents.ts
+var scheduledAgentRunsAsSchema = z25.object({
+  /** The person each run acts as; null when nobody owns it, so only the company's tools load. */
+  name: z25.string().nullable(),
+  /** That person's own connected tools. */
+  personalTools: z25.array(z25.string()),
+  /** The company's and organization's tools, and the platforms Baker connects to directly. */
+  companyTools: z25.array(z25.string()),
+  /** Set up, but nobody has signed in to them, so a run gets nothing from them. */
+  notSignedIn: z25.array(z25.string()).optional(),
+  /** The company switched connected tools off: only the platforms load. */
+  toolsOff: z25.literal(true).optional()
+});
+var AUTO_PUBLISH_REFUSAL = 'Publishing every run unreviewed is a standing authorization only the user can grant, on the item itself, so it is recorded against their name. Stage the item without it, and once this chat is published ask the user to switch on "Publish its work on its own" (under "When a run finishes") on the item in Scheduled agents.';
+var scheduledAgentsUnstageRequestSchema = z25.object({
+  chatId: z25.string().min(1),
+  /** The item: a published id or a temp_agent_* id this chat staged. */
+  ref: z25.string().min(1),
+  /** One change of it, by its `index` in `list`'s draft. Left out, every change staged on it. */
+  index: z25.number().int().min(0).optional()
+});
+var scheduledAgentsUnstageResponseSchema = z25.object({
+  ok: z25.literal(true),
+  data: z25.object({ ref: z25.string(), removed: z25.number().int().min(1) })
+});
+var scheduledAgentsListRequestSchema = z25.object({
+  /** Also return what this chat staged. */
+  chatId: z25.string().min(1).optional(),
+  /** Every item and staged change as stored, briefs included. Left out, the compact view below. */
+  full: z25.boolean().optional()
+});
+var scheduledAgentListItemSchema = z25.object({
+  id: z25.string(),
+  name: z25.string(),
+  description: z25.string(),
+  enabled: z25.boolean(),
+  trigger: scheduledAgentTriggerSchema,
+  occurrences: occurrencesSchema.optional(),
+  conditions: conditionsSchema.optional(),
+  cooldownMinutes: z25.number().optional(),
+  /** ISO. Only a one-off knows its next moment. */
+  nextRunAt: z25.string().optional(),
+  /** ISO. */
+  lastRunAt: z25.string().optional(),
+  firedCount: z25.number(),
+  totalRuns: z25.number(),
+  templateName: z25.string().optional(),
+  publishesOwnWork: z25.literal(true).optional(),
+  /** Whether the connected tool is reporting to an `app.event` item. */
+  listening: z25.object({ status: z25.string(), reason: z25.string().optional() }).optional()
+});
+var scheduledAgentStagedChangeSchema = z25.object({
+  index: z25.number().int().min(0),
+  kind: z25.enum(["create", "update", "delete"]),
+  /** The published id, or the temp_agent_* id a create returned. */
+  ref: z25.string(),
+  name: z25.string(),
+  description: z25.string().optional(),
+  trigger: scheduledAgentTriggerSchema.optional(),
+  enabled: z25.boolean().optional(),
+  /** For an update: the fields it changes. */
+  changes: z25.array(z25.string()).optional(),
+  result: z25.object({
+    status: z25.enum(["applied", "skipped", "failed"]),
+    reason: z25.string().optional(),
+    scheduledAgentId: z25.string().optional()
+  }).optional()
+});
+var scheduledAgentsListResponseSchema = z25.object({
+  ok: z25.literal(true),
+  data: z25.object({
+    published: z25.array(scheduledAgentListItemSchema),
+    draft: z25.object({
+      status: z25.enum(["active", "publishing", "discarded", "applied"]).nullable(),
+      ops: z25.array(scheduledAgentStagedChangeSchema)
+    }).nullable()
+  }),
+  hints: z25.array(z25.string()).optional()
+});
+
 // ../api/src/scheduledAgentTriggerCatalog.ts
+import { z as z26 } from "zod";
 var catalogTriggerSchema = z26.object({
   kind: z26.string(),
   label: z26.string(),
@@ -26580,10 +26618,10 @@ Example: baker ads meta ads retag 120252158038400247 --url-tags "utm_source={{si
     }
   },
   run: async ({ args: args5 }) => {
-    const { apiPost: apiPost2 } = await import("./client-3DGBQ2H3.js");
-    const { requireChatId: requireChatId2 } = await import("./env-BSG7TY5Y.js");
-    const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-AT5SRVH7.js");
-    const { handleMetaError: handleMetaError2 } = await import("./shared-HZ44PY2F.js");
+    const { apiPost: apiPost2 } = await import("./client-GR6YL3YX.js");
+    const { requireChatId: requireChatId2 } = await import("./env-4P5HOGNA.js");
+    const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-KMEPFOFT.js");
+    const { handleMetaError: handleMetaError2 } = await import("./shared-26NWGQ5G.js");
     try {
       const accountId = bareAccountId2(args5);
       const urlTags = typeof args5["url-tags"] === "string" ? args5["url-tags"] : void 0;
@@ -26728,10 +26766,10 @@ function duplicateCommand2(entity, label) {
       replace: { type: "boolean", description: "Pause the original once the copy publishes" }
     },
     run: async ({ args: args5 }) => {
-      const { apiPost: apiPost2 } = await import("./client-3DGBQ2H3.js");
-      const { requireChatId: requireChatId2 } = await import("./env-BSG7TY5Y.js");
-      const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-AT5SRVH7.js");
-      const { handleMetaError: handleMetaError2 } = await import("./shared-HZ44PY2F.js");
+      const { apiPost: apiPost2 } = await import("./client-GR6YL3YX.js");
+      const { requireChatId: requireChatId2 } = await import("./env-4P5HOGNA.js");
+      const { writeJsonEnvelope: writeJsonEnvelope2 } = await import("./output-KMEPFOFT.js");
+      const { handleMetaError: handleMetaError2 } = await import("./shared-26NWGQ5G.js");
       try {
         const accountId = bareAccountId2(args5);
         const chatId = requireChatId2();
@@ -64270,27 +64308,32 @@ var getCommand4 = defineCommand199({
 
 // src/commands/scheduled-agents/list.ts
 import { defineCommand as defineCommand200 } from "citty";
+var FULL_DESCRIPTION = "Return every item and staged change as stored, briefs included (tens of KB). Prefer `get <id>` for one item.";
 registerSchema({
   command: "scheduled-agents.list",
-  description: "List published scheduled agents. Includes draft state when BAKER_CHAT_ID is set, or --chat <id> to read an earlier chat's staged items instead.",
+  description: "List scheduled agents compactly: each published item's id, name, trigger, enabled and run counts, and each change this chat staged (index, kind, ref, name, trigger). Briefs are left out \u2014 `get <id>` returns one item in full, --full returns everything as stored. Includes draft state when BAKER_CHAT_ID is set, or --chat <id> to read an earlier chat's staged items instead.",
   args: {
-    chat: { type: "string", description: CHAT_READ_ARG.description, required: false }
+    chat: { type: "string", description: CHAT_READ_ARG.description, required: false },
+    full: { type: "boolean", description: FULL_DESCRIPTION, required: false }
   }
 });
 var listCommand17 = defineCommand200({
   meta: {
     name: "list",
-    description: "List scheduled agents. Includes staged draft ops when BAKER_CHAT_ID is set, or --chat <id> to read an earlier chat's staged items instead."
+    description: "List scheduled agents: id, name, trigger and status for each, plus this chat's staged changes when BAKER_CHAT_ID is set (or --chat <id> for an earlier chat's). Briefs are left out. Start here: baker scheduled-agents list; then baker scheduled-agents get <id> for one item's brief."
+  },
+  args: {
+    chat: CHAT_READ_ARG,
+    full: { type: "boolean", description: FULL_DESCRIPTION, required: false, default: false }
   },
-  args: { chat: CHAT_READ_ARG },
   run: async ({ args: args5 }) => {
     try {
       const env = getEnv();
-      const body = {};
       const chatId = typeof args5.chat === "string" && args5.chat.length > 0 ? args5.chat : env.BAKER_CHAT_ID;
-      if (chatId) {
-        body.chatId = chatId;
-      }
+      const body = {
+        ...chatId ? { chatId } : {},
+        ...args5.full === true ? { full: true } : {}
+      };
       const response = await apiPost("/api/scheduled-agents/list", body);
       writeJson(response);
     } catch (err) {
@@ -69383,261 +69426,6 @@ Full guide: __tooling__/docs/tools/baker/winning-ads.md`
   }
 });
 
-// src/unknown-flags.ts
-var ALWAYS_ACCEPTED = /* @__PURE__ */ new Set(["help", "h", "version"]);
-function subCommandsOf(command) {
-  const sub = command.subCommands;
-  return sub && typeof sub === "object" ? sub : null;
-}
-function argsOf(command) {
-  const args5 = command.args;
-  return args5 && typeof args5 === "object" ? args5 : null;
-}
-function resolveCommand2(root, argv) {
-  let command = root;
-  for (const token of argv) {
-    if (token === "--" || token.startsWith("-")) {
-      break;
-    }
-    const subCommands = subCommandsOf(command);
-    if (!subCommands) {
-      break;
-    }
-    const next = subCommands[token];
-    if (next === void 0) {
-      break;
-    }
-    if (typeof next !== "object") {
-      return { command, resolved: false };
-    }
-    command = next;
-  }
-  return { command, resolved: true };
-}
-function typeOf(def) {
-  return def && typeof def === "object" ? def.type : void 0;
-}
-function acceptedNames(command) {
-  const args5 = argsOf(command);
-  if (!args5) {
-    return null;
-  }
-  const names = new Set(ALWAYS_ACCEPTED);
-  for (const [name, def] of Object.entries(args5)) {
-    if (typeOf(def) === "positional") {
-      continue;
-    }
-    for (const spelling of [name, kebab(name), camel(name)]) {
-      names.add(spelling);
-      if (typeOf(def) === "boolean") {
-        names.add(`no-${spelling}`);
-      }
-    }
-  }
-  return names;
-}
-function kebab(name) {
-  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-}
-function camel(name) {
-  return name.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
-}
-function findUnknownFlags(root, argv) {
-  const { command, resolved } = resolveCommand2(root, argv);
-  if (!resolved) {
-    return [];
-  }
-  const accepted = acceptedNames(command);
-  if (!accepted) {
-    return [];
-  }
-  const unknown = [];
-  for (const token of argv) {
-    if (token === "--") {
-      break;
-    }
-    if (!token.startsWith("--")) {
-      continue;
-    }
-    const name = token.slice(2).split("=")[0] ?? "";
-    if (name.length > 0 && !accepted.has(name) && !unknown.includes(token)) {
-      unknown.push(token);
-    }
-  }
-  return unknown;
-}
-var SYNONYMS = {
-  from: ["start-date", "start", "since"],
-  since: ["start-date", "start"],
-  start: ["start-date", "since"],
-  to: ["end-date", "end", "until"],
-  until: ["end-date", "end"],
-  end: ["end-date", "until"],
-  path: ["landing"],
-  url: ["landing"]
-};
-function closestFlag(unknown, command) {
-  const accepted = acceptedNames(command);
-  if (!accepted) {
-    return null;
-  }
-  const name = unknown.replace(/^--/, "").split("=")[0] ?? "";
-  const synonym = SYNONYMS[name]?.find((candidate) => accepted.has(candidate));
-  if (synonym) {
-    return `--${synonym}`;
-  }
-  const scored = [...accepted].filter((candidate) => !ALWAYS_ACCEPTED.has(candidate)).map((candidate) => ({
-    candidate,
-    prefix: sharedPrefix(name, candidate),
-    distance: editDistance(name, candidate)
-  })).filter(({ prefix, distance }) => prefix >= 4 || distance <= typoBudget(name)).sort((a, b) => b.prefix - a.prefix || a.distance - b.distance);
-  return scored[0] ? `--${scored[0].candidate}` : null;
-}
-function typoBudget(name) {
-  return Math.max(1, Math.floor(name.length / 3));
-}
-function sharedPrefix(a, b) {
-  let i = 0;
-  while (i < a.length && i < b.length && a[i] === b[i]) {
-    i++;
-  }
-  return i;
-}
-function editDistance(a, b) {
-  let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
-  for (let i = 1; i <= a.length; i++) {
-    const current = [i];
-    for (let j = 1; j <= b.length; j++) {
-      const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
-      current.push(Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, substitution));
-    }
-    previous = current;
-  }
-  return previous[b.length] ?? 0;
-}
-function commandFor(root, argv) {
-  const { command, resolved } = resolveCommand2(root, argv);
-  return resolved ? command : null;
-}
-function suggestFlag(unknown, command) {
-  const flag = closestFlag(unknown, command);
-  if (!flag) {
-    return null;
-  }
-  const args5 = argsOf(command) ?? {};
-  const name = flag.slice(2);
-  const def = args5[name] ?? args5[camel(name)];
-  const described = def && typeof def === "object" ? def.description : void 0;
-  const description = typeof described === "string" ? described.split(/(?<!\b(?:e\.g|i\.e|vs))\.\s/)[0]?.trim().replace(/\.$/, "") : "";
-  return description ? { flag, description } : { flag };
-}
-function suggestionText(suggestion) {
-  if (!suggestion) {
-    return "";
-  }
-  return suggestion.description ? `Did you mean ${suggestion.flag}? It is described as: ${suggestion.description}. ` : `Did you mean ${suggestion.flag}? `;
-}
-var OUTPUT_EXPLANATION = "This command has no --output option: `--output json` is accepted by every command that prints the JSON envelope, and md or files only where `baker schema` lists `output`. Drop the option and read the default output. ";
-function unknownFlagEnvelope(unknown, commandPath, suggestion, hasSchema) {
-  const list = unknown.join(", ");
-  return {
-    ok: false,
-    error: {
-      code: "UNKNOWN_ARGUMENT",
-      message: `${list} ${unknown.length > 1 ? "are not options" : "is not an option"} of \`baker ${commandPath}\`.`,
-      fix: {
-        action: hasSchema ? "check_schema" : "check_help",
-        explanation: (unknown.some((flag) => flag === "--output" || flag.startsWith("--output=")) ? OUTPUT_EXPLANATION : "") + suggestionText(suggestion) + `Run \`${hasSchema ? `baker schema ${commandPath}` : `baker ${commandPath} --help`}\` to see every option this command takes. Do not re-run the same call: until this version an unrecognised option was accepted and ignored, so a command that looked like it had filtered or narrowed the result was in fact answering the unfiltered question.`
-      },
-      retryable: false
-    }
-  };
-}
-function commandPathOf(root, argv) {
-  const path48 = [];
-  let command = root;
-  for (const token of argv) {
-    if (token === "--" || token.startsWith("-")) {
-      break;
-    }
-    const subCommands = subCommandsOf(command);
-    const next = subCommands?.[token];
-    if (next === void 0 || typeof next !== "object") {
-      break;
-    }
-    path48.push(token);
-    command = next;
-  }
-  return path48.join(" ");
-}
-function refuseUnknownFlags(root, argv) {
-  const unknown = findUnknownFlags(root, argv);
-  if (unknown.length === 0) {
-    return;
-  }
-  const command = commandFor(root, argv);
-  const first = unknown[0];
-  const suggestion = command && first ? suggestFlag(first, command) : null;
-  const path48 = commandPathOf(root, argv);
-  process.stdout.write(
-    `${JSON.stringify(unknownFlagEnvelope(unknown, path48, suggestion, findSchema(path48.split(" ")) !== void 0), null, 2)}
-`
-  );
-  process.exit(1);
-}
-
-// src/output-flag.ts
-var FLAG = "--output";
-var ENVELOPE = "json";
-var PRINTS_NO_ENVELOPE = /* @__PURE__ */ new Set([
-  "analytics sending-events",
-  "canvas run",
-  "canvas rerun",
-  "canvas sync-definition"
-]);
-function declaredArg(command, name) {
-  const args5 = command.args;
-  if (!args5 || typeof args5 !== "object" || !(name in args5)) {
-    return null;
-  }
-  const def = args5[name];
-  return def && typeof def === "object" ? def : {};
-}
-function envelopeRequests(argv) {
-  const end = argv.indexOf("--");
-  const limit = end === -1 ? argv.length : end;
-  const found = [];
-  for (let index = 0; index < limit; index++) {
-    const token = argv[index];
-    if (token === `${FLAG}=${ENVELOPE}`) {
-      found.push({ index, length: 1 });
-    } else if (token === FLAG && argv[index + 1] === ENVELOPE && index + 1 < limit) {
-      found.push({ index, length: 2 });
-      index++;
-    }
-  }
-  return found;
-}
-function outputFlagForCommand(root, argv) {
-  const requests = envelopeRequests(argv);
-  if (requests.length === 0) {
-    return argv;
-  }
-  const command = commandFor(root, argv);
-  if (!command || declaredArg(command, "output") || PRINTS_NO_ENVELOPE.has(commandPathOf(root, argv))) {
-    return argv;
-  }
-  const jsonSwitch = declaredArg(command, "json")?.type === "boolean";
-  const dropped = new Set(requests.flatMap(({ index, length }) => length === 2 ? [index, index + 1] : [index]));
-  const first = requests[0]?.index;
-  return argv.flatMap((token, index) => {
-    if (!dropped.has(index)) {
-      return [token];
-    }
-    return jsonSwitch && index === first ? ["--json"] : [];
-  });
-}
-
 // src/version.ts
 import { readFileSync as readFileSync21 } from "fs";
 function packageJsonUrl() {
@@ -69664,6 +69452,7 @@ var main = defineCommand248({
 Auth: Set BAKER_API_KEY (starts with bk_) and BAKER_API_URL environment variables.
 Chat: Set BAKER_CHAT_ID for action and scheduled-agent commands that stage changes against a chat.
 Output: All commands return JSON envelopes: { ok: true, data: ... } or { ok: false, error: { code, message } }.
+Fields: --fields a,b,c keeps only those keys of each record in data, on every command that prints the envelope.
 Formats: --output json works on every command that prints the envelope. --output md|files only where 'baker schema <command>' lists output. (The research commands additionally accept csv and jsonl.)
 Introspection: Run 'baker schema <command>' to inspect argument schemas.`
   },
@@ -69703,6 +69492,11 @@ installStreamTaps();
 logInvocation(process.argv.slice(2));
 installExitRecord();
 process.argv = [...process.argv.slice(0, 2), ...outputFlagForCommand(main, process.argv.slice(2))];
+var fieldsFlag = takeFieldsFlag(main, process.argv.slice(2));
+if (fieldsFlag.fields) {
+  process.argv = [...process.argv.slice(0, 2), ...fieldsFlag.argv];
+  installFieldMask(fieldsFlag.fields, commandPathOf(main, fieldsFlag.argv));
+}
 refuseUnknownFlags(main, process.argv.slice(2));
 process.argv = [...process.argv.slice(0, 2), ...cacheFlagForParser(process.argv.slice(2))];
 runMain(main);