@withgauge/cli 0.2.0 → 0.4.0

package/dist/index.js

@@ -141,10 +141,10 @@ var batterySpecSchema = z2.object({
   prompts: z2.array(batteryPromptSpecSchema).min(1)
 });
 var batteryPlanScheduleSchema = z2.object({
-  action: z2.enum(["create", "update"]),
+  action: z2.enum(["create", "update", "none"]),
   repoUrl: z2.string().nullable(),
   repoRef: z2.string().nullable(),
-  /** Runs this schedule would enqueue (agents × samples; 0 unless `expand`). */
+  /** Runs this target would enqueue (agents × samples; 0 unless `expand`). */
   runs: z2.number().int()
 });
 var batteryPlanPromptSchema = z2.object({
@@ -342,6 +342,54 @@ var listBrandsQuerySchema = listQuerySchema.extend({
 });
 var brandListResponseSchema = listResponseSchema(brandSchema);
 
+// ../packages/api-schemas/src/device.ts
+import { z as z5 } from "zod";
+var deviceAuthorizeRequestSchema = z5.object({
+  /** Device label (the CLI's hostname) for display + token naming. */
+  deviceName: z5.string().trim().max(64).optional(),
+  /** Optional: email a magic-link that lands on the approval page pre-scoped
+   *  to this device (best-effort — the printed URL always works regardless). */
+  email: z5.string().trim().email().max(320).optional()
+});
+var deviceAuthorizeResponseSchema = z5.object({
+  /** The one-time secret the CLI polls with (never shown again). */
+  deviceCode: z5.string(),
+  /** Short human-typed code the user confirms in the browser (e.g. WXYZ-1234). */
+  userCode: z5.string(),
+  /** Where the user approves (e.g. https://…/cli/authorize). */
+  verificationUri: z5.string(),
+  /** verificationUri with the code pre-filled, for one-click / QR. */
+  verificationUriComplete: z5.string(),
+  /** Minimum seconds between polls. */
+  interval: z5.number().int().positive(),
+  /** Seconds until the device code expires. */
+  expiresIn: z5.number().int().positive(),
+  /** Whether a magic-link email was dispatched (best-effort). */
+  emailSent: z5.boolean()
+});
+var deviceTokenRequestSchema = z5.object({
+  deviceCode: z5.string().min(1)
+});
+var deviceTokenApprovedSchema = z5.object({
+  status: z5.literal("approved"),
+  /** The `gauge_…` bearer secret. Store it now — never returned again. */
+  accessToken: z5.string(),
+  tokenType: z5.literal("bearer"),
+  /** ISO-8601 expiry, or null for no expiry. */
+  expiresAt: z5.string().nullable()
+});
+var deviceTokenResultSchema = z5.discriminatedUnion("status", [
+  // Not yet approved — keep polling at `interval`.
+  z5.object({ status: z5.literal("pending") }),
+  // Polled faster than `interval` — back off by `interval` seconds.
+  z5.object({ status: z5.literal("slow_down"), interval: z5.number().int() }),
+  // The user explicitly denied the request. Stop.
+  z5.object({ status: z5.literal("denied") }),
+  // The device code expired or is unknown/already-redeemed. Stop and restart.
+  z5.object({ status: z5.literal("expired") }),
+  deviceTokenApprovedSchema
+]);
+
 // ../packages/api-schemas/src/keys.ts
 var keys_exports = {};
 __export(keys_exports, {
@@ -352,54 +400,69 @@ __export(keys_exports, {
   setProviderKeyBodySchema: () => setProviderKeyBodySchema,
   setProviderKeyResponseSchema: () => setProviderKeyResponseSchema
 });
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var PROVIDER_TYPES = ["anthropic", "openai"];
-var providerTypeSchema = z5.enum(PROVIDER_TYPES);
-var setProviderKeyBodySchema = z5.object({
+var providerTypeSchema = z6.enum(PROVIDER_TYPES);
+var setProviderKeyBodySchema = z6.object({
   /** The raw provider API key. Verified + stored server-side (AWS Secrets
    *  Manager); never persisted in the app DB and never echoed back. */
-  key: z5.string().min(1)
+  key: z6.string().min(1)
 });
-var setProviderKeyResponseSchema = z5.object({
+var setProviderKeyResponseSchema = z6.object({
   providerType: providerTypeSchema,
-  last4: z5.string()
+  last4: z6.string()
 });
-var providerKeySchema = z5.object({
+var providerKeySchema = z6.object({
   providerType: providerTypeSchema,
-  last4: z5.string(),
-  createdAt: z5.string(),
+  last4: z6.string(),
+  createdAt: z6.string(),
   /** When the key was last saved/rotated. */
-  updatedAt: z5.string()
+  updatedAt: z6.string()
 });
 var providerKeyListResponseSchema = listResponseSchema(providerKeySchema);
 
 // ../packages/api-schemas/src/me.ts
-import { z as z6 } from "zod";
-var meUserSchema = z6.object({
-  id: z6.string(),
-  email: z6.string().nullable(),
-  isSuperuser: z6.boolean()
+import { z as z7 } from "zod";
+var meUserSchema = z7.object({
+  id: z7.string(),
+  email: z7.string().nullable(),
+  isSuperuser: z7.boolean()
 });
-var meOrgSchema = z6.object({
-  slug: z6.string(),
+var meOrgSchema = z7.object({
+  slug: z7.string(),
   // Gauge's immutable Organization.public_id; null for LOCAL orgs.
-  publicId: z6.string().nullable(),
-  name: z6.string()
+  publicId: z7.string().nullable(),
+  name: z7.string()
 });
-var meResponseSchema = z6.object({
+var meResponseSchema = z7.object({
   user: meUserSchema,
   // Membership-scoped for normal users; superusers see every org (mirrors the
   // web tier's userOrgs).
-  orgs: z6.array(meOrgSchema)
+  orgs: z7.array(meOrgSchema)
+});
+
+// ../packages/api-schemas/src/orgs.ts
+import { z as z8 } from "zod";
+var createOrgRequestSchema = z8.object({
+  /** Workspace display name; the slug is derived server-side. */
+  name: z8.string().trim().min(1).max(200),
+  /** Optional company site (logo source; stamped onto the org). */
+  website: z8.string().trim().max(300).optional()
+});
+var createOrgResponseSchema = z8.object({
+  slug: z8.string(),
+  name: z8.string(),
+  // LOCAL orgs never have a Gauge publicId.
+  publicId: z8.string().nullable()
 });
 
 // ../packages/api-schemas/src/prompts.ts
-import { z as z10 } from "zod";
+import { z as z13 } from "zod";
 
 // ../packages/api-schemas/src/schedules.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 var AGENTS = ["CLAUDE_CODE", "CODEX_CLI", "CURSOR"];
-var agentSchema = z7.enum(AGENTS);
+var agentSchema = z9.enum(AGENTS);
 var CADENCES = [
   "NONE",
   "DAILY",
@@ -407,184 +470,455 @@ var CADENCES = [
   "MONTHLY",
   "DAYS_PER_WEEK"
 ];
-var cadenceSchema = z7.enum(CADENCES);
-var daysPerWeekSchema = z7.number().int().min(1).max(7);
-var scheduleSchema = z7.object({
-  id: z7.string(),
-  promptId: z7.string(),
-  /** Base repo to run against; null = the default scaffold. */
-  repoUrl: z7.string().nullable(),
+var cadenceSchema = z9.enum(CADENCES);
+var daysPerWeekSchema = z9.number().int().min(1).max(7);
+var scheduleRepoSchema = z9.object({
+  repoUrl: z9.string(),
   /** Branch/ref; null = the repo's default branch. */
-  repoRef: z7.string().nullable(),
+  repoRef: z9.string().nullable()
+});
+var scheduleSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
   cadence: cadenceSchema,
   /** Only set when cadence is DAYS_PER_WEEK (1–7). */
-  daysPerWeek: z7.number().int().nullable(),
-  samplesPerCycle: z7.number().int(),
-  agents: z7.array(agentSchema),
+  daysPerWeek: z9.number().int().nullable(),
+  samplesPerCycle: z9.number().int(),
+  agents: z9.array(agentSchema),
   /** Pinned model id; null = the agent's default. */
-  model: z7.string().nullable(),
-  /** Cohort label for experiment analysis; null for ad-hoc schedules. */
-  experiment: z7.string().nullable(),
-  createdAt: z7.string(),
-  updatedAt: z7.string()
+  model: z9.string().nullable(),
+  /** Repo targets in stable expansion order; empty = the default scaffold. */
+  repos: z9.array(scheduleRepoSchema),
+  /** Cohort label for experiment analysis; null outside labeled experiments. */
+  experiment: z9.string().nullable(),
+  enabled: z9.boolean(),
+  lastExpandedAt: z9.string().nullable(),
+  /** Member prompt ids, in stable expansion order. */
+  promptIds: z9.array(z9.string()),
+  promptCount: z9.number().int(),
+  createdAt: z9.string(),
+  updatedAt: z9.string()
 });
 var scheduleListResponseSchema = listResponseSchema(scheduleSchema);
-var createScheduleBodySchema = z7.object({
-  repoUrl: z7.string().min(1).nullish(),
-  repoRef: z7.string().min(1).nullish(),
+var scheduleRepoInputSchema = z9.object({
+  repoUrl: z9.string().min(1),
+  repoRef: z9.string().min(1).nullish()
+});
+var createScheduleBodySchema = z9.object({
+  name: z9.string().min(1, "name is required"),
   cadence: cadenceSchema.default("NONE"),
   daysPerWeek: daysPerWeekSchema.optional(),
-  agents: z7.array(agentSchema).min(1, "Select at least one agent")
-});
-var updateScheduleBodySchema = z7.object({
-  repoUrl: z7.string().min(1).nullish(),
-  repoRef: z7.string().min(1).nullish(),
+  samplesPerCycle: z9.number().int().min(1).default(1),
+  agents: z9.array(agentSchema).min(1, "Select at least one agent"),
+  model: z9.string().min(1).nullish(),
+  /** Repo targets; empty = the default scaffold (greenfield). */
+  repos: z9.array(scheduleRepoInputSchema).default([]),
+  /** Member prompt ids (resolved by the caller — tag→prompt resolution is a
+   *  UI-side authoring convenience, never stored). */
+  promptIds: z9.array(z9.string().min(1)).default([]),
+  enabled: z9.boolean().default(true)
+});
+var updateScheduleBodySchema = z9.object({
+  name: z9.string().min(1).optional(),
   cadence: cadenceSchema.optional(),
   daysPerWeek: daysPerWeekSchema.optional(),
-  agents: z7.array(agentSchema).min(1, "Select at least one agent").optional()
+  samplesPerCycle: z9.number().int().min(1).optional(),
+  agents: z9.array(agentSchema).min(1, "Select at least one agent").optional(),
+  model: z9.string().min(1).nullish(),
+  repos: z9.array(scheduleRepoInputSchema).optional(),
+  promptIds: z9.array(z9.string().min(1)).optional(),
+  enabled: z9.boolean().optional()
+});
+var runScheduleResponseSchema = z9.object({
+  batchIds: z9.array(z9.string()),
+  runIds: z9.array(z9.string()),
+  blocked: z9.enum(["insufficient_credits", "needs_provider_key"]).optional(),
+  notReady: z9.array(
+    z9.object({
+      repoUrl: z9.string(),
+      status: z9.enum(["building", "failed", "none"])
+    })
+  ).optional()
 });
 
 // ../packages/api-schemas/src/tags.ts
-import { z as z8 } from "zod";
-var tagSchema = z8.object({
-  id: z8.string(),
-  name: z8.string(),
+import { z as z10 } from "zod";
+var tagSchema = z10.object({
+  id: z10.string(),
+  name: z10.string(),
   /** A Mantine palette name (e.g. "blue", "grape"); unknown values are
    *  normalized server-side to the default ("gray"). */
-  color: z8.string()
+  color: z10.string()
 });
-var createTagBodySchema = z8.object({
-  name: z8.string().min(1),
-  color: z8.string().optional()
+var createTagBodySchema = z10.object({
+  name: z10.string().min(1),
+  color: z10.string().optional()
 });
-var updateTagBodySchema = z8.object({
-  name: z8.string().min(1).optional(),
-  color: z8.string().optional()
+var updateTagBodySchema = z10.object({
+  name: z10.string().min(1).optional(),
+  color: z10.string().optional()
 });
 var tagListResponseSchema = listResponseSchema(tagSchema);
 
 // ../packages/api-schemas/src/topics.ts
-import { z as z9 } from "zod";
-var topicSchema = z9.object({
-  id: z9.string(),
-  name: z9.string()
+import { z as z11 } from "zod";
+var topicSchema = z11.object({
+  id: z11.string(),
+  name: z11.string()
 });
-var createTopicBodySchema = z9.object({
-  name: z9.string().min(1, "name is required")
+var createTopicBodySchema = z11.object({
+  name: z11.string().min(1, "name is required")
 });
 var topicListResponseSchema = listResponseSchema(topicSchema);
 
+// ../packages/api-schemas/src/web-fixtures.ts
+var web_fixtures_exports = {};
+__export(web_fixtures_exports, {
+  MAX_WEB_FIXTURE_BYTES: () => MAX_WEB_FIXTURE_BYTES,
+  webFixtureSchema: () => webFixtureSchema
+});
+import { z as z12 } from "zod";
+var MAX_WEB_FIXTURE_BYTES = 1e6;
+function withoutFragment(raw) {
+  const fragment = raw.indexOf("#");
+  return fragment === -1 ? raw : raw.slice(0, fragment);
+}
+var searchResultSchema = z12.object({
+  title: z12.string().min(1),
+  url: z12.url().transform(withoutFragment),
+  snippet: z12.string()
+});
+var searchFixtureSchema = z12.object({
+  query: z12.string().trim().min(1),
+  results: z12.array(searchResultSchema)
+});
+var pageFixtureSchema = z12.object({
+  url: z12.url().transform(withoutFragment),
+  status: z12.int().min(100).max(599).default(200),
+  contentType: z12.string().trim().min(1).default("text/html"),
+  body: z12.string()
+});
+var webFixtureSchema = z12.object({
+  version: z12.literal(1),
+  searches: z12.array(searchFixtureSchema).default([]),
+  pages: z12.array(pageFixtureSchema).default([])
+}).superRefine((fixture, ctx) => {
+  const queries = /* @__PURE__ */ new Set();
+  fixture.searches.forEach((entry, index) => {
+    if (queries.has(entry.query)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["searches", index, "query"],
+        message: `duplicate normalized query: ${entry.query}`
+      });
+    }
+    queries.add(entry.query);
+  });
+  const urls = /* @__PURE__ */ new Set();
+  fixture.pages.forEach((entry, index) => {
+    if (urls.has(entry.url)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["pages", index, "url"],
+        message: `duplicate normalized URL: ${entry.url}`
+      });
+    }
+    urls.add(entry.url);
+  });
+  const bytes = new TextEncoder().encode(JSON.stringify(fixture)).byteLength;
+  if (bytes > MAX_WEB_FIXTURE_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      message: `serialized fixture is ${bytes} bytes; maximum is ${MAX_WEB_FIXTURE_BYTES}`
+    });
+  }
+});
+
 // ../packages/api-schemas/src/prompts.ts
 var SCENARIOS = ["GREENFIELD", "MIGRATION"];
-var scenarioSchema = z10.enum(SCENARIOS);
-var promptSummarySchema = z10.object({
-  id: z10.string(),
-  text: z10.string(),
+var scenarioSchema = z13.enum(SCENARIOS);
+var promptSummarySchema = z13.object({
+  id: z13.string(),
+  text: z13.string(),
   scenario: scenarioSchema,
-  isBranded: z10.boolean(),
+  isBranded: z13.boolean(),
   /** Battery-spec identity (idempotent applies); null for UI/CLI-created prompts. */
-  externalKey: z10.string().nullable(),
+  externalKey: z13.string().nullable(),
   topic: topicSchema.nullable(),
-  tags: z10.array(tagSchema),
-  scheduleCount: z10.number().int(),
-  createdAt: z10.string()
+  tags: z13.array(tagSchema),
+  scheduleCount: z13.number().int(),
+  createdAt: z13.string()
+});
+var promptScheduleRefSchema = z13.object({
+  id: z13.string(),
+  name: z13.string(),
+  cadence: cadenceSchema,
+  daysPerWeek: z13.number().int().nullable(),
+  enabled: z13.boolean()
 });
 var promptDetailSchema = promptSummarySchema.extend({
-  schedules: z10.array(scheduleSchema)
+  schedules: z13.array(promptScheduleRefSchema)
 });
 var promptListResponseSchema = listResponseSchema(promptSummarySchema);
 var listPromptsQuerySchema = listQuerySchema.extend({
-  topic: z10.string().min(1).optional(),
-  tag: z10.string().min(1).optional(),
-  q: z10.string().min(1).optional()
+  topic: z13.string().min(1).optional(),
+  tag: z13.string().min(1).optional(),
+  q: z13.string().min(1).optional()
 });
-var createPromptBodySchema = z10.object({
-  text: z10.string().min(1, "text is required"),
+var createPromptBodySchema = z13.object({
+  text: z13.string().min(1, "text is required"),
   scenario: scenarioSchema.default("GREENFIELD"),
-  isBranded: z10.boolean().default(false),
-  topic: z10.string().min(1).optional(),
-  tags: z10.array(z10.string().min(1)).default([]),
-  schedules: z10.array(createScheduleBodySchema).default([])
-});
-var createPromptResponseSchema = promptDetailSchema.extend({
-  firstRunBlocked: z10.enum(["insufficient_credits", "needs_provider_key"]).optional()
-});
-var updatePromptBodySchema = z10.object({
-  text: z10.string().min(1).optional(),
-  isBranded: z10.boolean().optional(),
-  topicId: z10.string().min(1).nullish(),
-  tags: z10.array(z10.string().min(1)).optional()
-});
-var runPromptBodySchema = z10.object({
-  agents: z10.array(agentSchema).min(1).optional(),
-  scheduleIds: z10.array(z10.string().min(1)).min(1).optional()
-});
-var runPromptResponseSchema = z10.object({
-  batchIds: z10.array(z10.string()),
-  runIds: z10.array(z10.string()),
-  /** Present when SOME schedules hit a billing gate but at least one run was
-   *  enqueued (mirrors the battery apply response; an all-blocked run is a
-   *  402 error instead). */
-  blocked: z10.enum(["insufficient_credits", "needs_provider_key"]).optional()
+  isBranded: z13.boolean().default(false),
+  topic: z13.string().min(1).optional(),
+  tags: z13.array(z13.string().min(1)).default([])
+});
+var updatePromptBodySchema = z13.object({
+  text: z13.string().min(1).optional(),
+  isBranded: z13.boolean().optional(),
+  topicId: z13.string().min(1).nullish(),
+  tags: z13.array(z13.string().min(1)).optional()
+});
+var runPromptBodySchema = z13.object({
+  agents: z13.array(agentSchema).min(1, "Select at least one agent").default(["CLAUDE_CODE", "CODEX_CLI"]),
+  repoUrl: z13.string().min(1).nullish(),
+  repoRef: z13.string().min(1).nullish(),
+  samplesPerCycle: z13.number().int().min(1).max(10).default(1),
+  webFixture: webFixtureSchema.optional()
+});
+var runPromptResponseSchema = z13.object({
+  batchIds: z13.array(z13.string()),
+  runIds: z13.array(z13.string())
+});
+
+// ../packages/api-schemas/src/query.ts
+import { z as z15 } from "zod";
+
+// ../packages/api-schemas/src/stats.ts
+import { z as z14 } from "zod";
+var BRAND_KINDS2 = ["OWNED", "COMPETITOR", "OTHER"];
+var brandKindSchema2 = z14.enum(BRAND_KINDS2);
+var brandRankingSchema = z14.object({
+  rank: z14.number().int(),
+  brandId: z14.string(),
+  brandName: z14.string(),
+  kind: brandKindSchema2,
+  installs: z14.number().int(),
+  installRate: z14.number(),
+  mentionRate: z14.number(),
+  /** Movement between the two most recent batch windows; null if not ranked in both. */
+  deltaRank: z14.number().int().nullable()
+});
+var packageRateSchema = z14.object({
+  ecosystem: z14.string(),
+  name: z14.string(),
+  brandName: z14.string().optional(),
+  kind: brandKindSchema2.optional(),
+  installs: z14.number().int(),
+  rate: z14.number()
+});
+var brandRateSchema = z14.object({
+  brandId: z14.string(),
+  brandName: z14.string(),
+  kind: brandKindSchema2,
+  installs: z14.number().int(),
+  rate: z14.number()
+});
+var brandFunnelRowSchema = z14.object({
+  brandId: z14.string(),
+  brandName: z14.string(),
+  kind: brandKindSchema2,
+  mentionRate: z14.number(),
+  installRate: z14.number()
+});
+var domainRateSchema = z14.object({
+  domain: z14.string(),
+  runs: z14.number().int(),
+  rate: z14.number(),
+  requests: z14.number().int(),
+  brandName: z14.string().optional(),
+  owned: z14.boolean().optional()
+});
+var statsFreshnessSchema = z14.object({
+  /** Newest run-ingest time across the org (ISO), or null if nothing ingested. */
+  watermark: z14.string().nullable(),
+  /** Runs that succeeded recently but haven't landed in the warehouse yet. */
+  pending: z14.number().int(),
+  /** False when the freshness read itself failed (distinguish from genuine zero). */
+  available: z14.boolean()
+});
+var statsResponseSchema = (item) => z14.object({ items: z14.array(item), freshness: statsFreshnessSchema });
+var rankingsResponseSchema = statsResponseSchema(brandRankingSchema);
+var installsResponseSchema = statsResponseSchema(packageRateSchema);
+var brandsResponseSchema = statsResponseSchema(brandRateSchema);
+var funnelResponseSchema = statsResponseSchema(brandFunnelRowSchema);
+var domainsResponseSchema = statsResponseSchema(domainRateSchema);
+
+// ../packages/api-schemas/src/query.ts
+var DATASETS = [
+  "runs",
+  "installs",
+  "mentions",
+  "web",
+  "network",
+  "files",
+  "tokens"
+];
+var datasetSchema = z15.enum(DATASETS);
+var WHERE_OPS = [
+  "eq",
+  "neq",
+  "in",
+  "notIn",
+  "contains",
+  "gt",
+  "gte",
+  "lt",
+  "lte"
+];
+var whereOpSchema = z15.enum(WHERE_OPS);
+var GRANULARITIES = ["day", "week", "month"];
+var granularitySchema = z15.enum(GRANULARITIES);
+var DEFAULT_QUERY_LIMIT = 50;
+var MAX_QUERY_LIMIT = 1e3;
+var scalar = z15.union([z15.string(), z15.number(), z15.boolean()]);
+var whereClauseSchema = z15.object({
+  dimension: z15.string().min(1),
+  op: whereOpSchema,
+  value: z15.union([scalar, z15.array(scalar)])
+});
+var queryFiltersSchema = z15.object({
+  prompt: z15.string(),
+  topic: z15.array(z15.string()),
+  tag: z15.array(z15.string()),
+  repo: z15.array(z15.string()),
+  language: z15.array(z15.string()),
+  framework: z15.array(z15.string()),
+  size: z15.array(z15.string()),
+  agent: z15.array(z15.string()),
+  model: z15.array(z15.string()),
+  scenario: z15.array(z15.string()),
+  experiment: z15.array(z15.string()),
+  branded: z15.boolean()
+}).partial();
+var dateRangeSchema = z15.object({
+  since: z15.string(),
+  until: z15.string(),
+  lastDays: z15.number().int().positive()
+}).partial();
+var orderBySchema = z15.object({
+  /** A selected dimension or metric name. */
+  key: z15.string().min(1),
+  dir: z15.enum(["asc", "desc"]).default("desc")
+});
+var querySpecSchema = z15.object({
+  dataset: datasetSchema.default("runs"),
+  dimensions: z15.array(z15.string()).default([]),
+  metrics: z15.array(z15.string()).min(1, "at least one metric is required"),
+  filters: queryFiltersSchema.default({}),
+  where: z15.array(whereClauseSchema).default([]),
+  dateRange: dateRangeSchema.optional(),
+  orderBy: z15.array(orderBySchema).default([]),
+  limit: z15.number().int().min(1).max(MAX_QUERY_LIMIT).default(DEFAULT_QUERY_LIMIT),
+  granularity: granularitySchema.default("day"),
+  /** When true, the response echoes the compiled SQL (params bound, not inlined). */
+  explain: z15.boolean().default(false)
+});
+var columnKindSchema = z15.enum(["dimension", "metric"]);
+var queryColumnSchema = z15.object({
+  key: z15.string(),
+  kind: columnKindSchema
+});
+var queryRowSchema = z15.record(
+  z15.string(),
+  z15.union([z15.string(), z15.number(), z15.boolean(), z15.null()])
+);
+var queryResponseSchema = z15.object({
+  columns: z15.array(queryColumnSchema),
+  rows: z15.array(queryRowSchema),
+  /** Present only when the request set explain=true. */
+  sql: z15.string().optional(),
+  freshness: statsFreshnessSchema
+});
+var fieldTypeSchema = z15.enum([
+  "string",
+  "number",
+  "rate",
+  "date",
+  "boolean"
+]);
+var fieldSchema = z15.object({
+  name: z15.string(),
+  type: fieldTypeSchema,
+  /** One-line human/agent hint. */
+  description: z15.string().optional()
+});
+var datasetMetaSchema = z15.object({
+  name: datasetSchema,
+  grain: z15.string(),
+  dimensions: z15.array(fieldSchema),
+  metrics: z15.array(fieldSchema)
+});
+var metadataResponseSchema = z15.object({
+  datasets: z15.array(datasetMetaSchema)
 });
 
 // ../packages/api-schemas/src/repos.ts
-import { z as z11 } from "zod";
+import { z as z16 } from "zod";
 var REPO_SIZE_BUCKETS = [
   "small",
   "medium",
   "large",
   "xlarge"
 ];
-var repoSizeBucketSchema = z11.enum(REPO_SIZE_BUCKETS);
-var repoSchema = z11.object({
-  url: z11.string(),
-  name: z11.string(),
-  isSystem: z11.boolean(),
-  languages: z11.array(z11.string()),
-  frameworks: z11.array(z11.string()),
+var repoSizeBucketSchema = z16.enum(REPO_SIZE_BUCKETS);
+var repoSchema = z16.object({
+  url: z16.string(),
+  name: z16.string(),
+  isSystem: z16.boolean(),
+  languages: z16.array(z16.string()),
+  frameworks: z16.array(z16.string()),
   /** Faceted labels (complexity:L2, buildable:yes, stack:nextjs, …). */
-  tags: z11.array(z11.string()),
-  primaryLanguage: z11.string(),
-  sizeKb: z11.number(),
+  tags: z16.array(z16.string()),
+  primaryLanguage: z16.string(),
+  sizeKb: z16.number(),
   sizeBucket: repoSizeBucketSchema.nullable(),
-  stars: z11.number()
+  stars: z16.number()
 });
 var repoListResponseSchema = listResponseSchema(repoSchema);
-var addRepoBodySchema = z11.object({
-  url: z11.string().min(1, "url is required"),
+var addRepoBodySchema = z16.object({
+  url: z16.string().min(1, "url is required"),
   /**
    * Reserved (accepted, not yet persisted): the catalog keys repos by URL only
    * — `fact_repo` has no ref column and metadata sync always reads the default
    * branch. Kept in the wire format so `gauge repos add --ref` is stable once
    * the catalog learns refs.
    */
-  ref: z11.string().min(1).optional(),
+  ref: z16.string().min(1).optional(),
   /** Display name; defaults to the `owner/repo` label of the URL. */
-  name: z11.string().min(1).optional(),
+  name: z16.string().min(1).optional(),
   /** Manual override; defaults to frameworks detected from the repo's manifests. */
-  frameworks: z11.array(z11.string()).optional(),
-  tags: z11.array(z11.string()).optional()
+  frameworks: z16.array(z16.string()).optional(),
+  tags: z16.array(z16.string()).optional()
 });
-var updateRepoBodySchema = z11.object({
-  url: z11.string().min(1, "url is required"),
-  name: z11.string().min(1).optional(),
-  frameworks: z11.array(z11.string()).optional(),
-  tags: z11.array(z11.string()).optional()
+var updateRepoBodySchema = z16.object({
+  url: z16.string().min(1, "url is required"),
+  name: z16.string().min(1).optional(),
+  frameworks: z16.array(z16.string()).optional(),
+  tags: z16.array(z16.string()).optional()
 });
-var resyncRepoBodySchema = z11.object({
-  url: z11.string().min(1, "url is required")
+var resyncRepoBodySchema = z16.object({
+  url: z16.string().min(1, "url is required")
 });
-var deleteRepoQuerySchema = z11.object({
-  url: z11.string().min(1, "url is required")
+var deleteRepoQuerySchema = z16.object({
+  url: z16.string().min(1, "url is required")
 });
-var repoSyncResultSchema = z11.object({
+var repoSyncResultSchema = z16.object({
   repo: repoSchema,
-  synced: z11.boolean()
+  synced: z16.boolean()
 });
 
 // ../packages/api-schemas/src/runs.ts
-import { z as z12 } from "zod";
+import { z as z17 } from "zod";
 var RUN_STATUSES = [
   "QUEUED",
   "CLAIMED",
@@ -595,152 +929,143 @@ var RUN_STATUSES = [
   "TIMED_OUT",
   "CANCELED"
 ];
-var runStatusSchema = z12.enum(RUN_STATUSES);
+var runStatusSchema = z17.enum(RUN_STATUSES);
 var AGENTS2 = ["CLAUDE_CODE", "CODEX_CLI", "CURSOR"];
-var agentSchema2 = z12.enum(AGENTS2);
-var runStatusFilterSchema = z12.string().transform(
+var agentSchema2 = z17.enum(AGENTS2);
+var runStatusFilterSchema = z17.string().transform(
   (raw) => raw.split(",").map((s) => s.trim().toUpperCase()).filter(Boolean)
-).pipe(z12.array(runStatusSchema).min(1));
+).pipe(z17.array(runStatusSchema).min(1));
 var runListQuerySchema = listQuerySchema.extend({
   status: runStatusFilterSchema.optional(),
-  batch: z12.string().optional(),
-  prompt: z12.string().optional(),
-  experiment: z12.string().optional(),
-  since: z12.string().optional()
+  batch: z17.string().optional(),
+  prompt: z17.string().optional(),
+  experiment: z17.string().optional(),
+  since: z17.string().optional()
 });
-var runListItemSchema = z12.object({
-  id: z12.string(),
+var runListItemSchema = z17.object({
+  id: z17.string(),
   status: runStatusSchema,
   agent: agentSchema2,
-  model: z12.string(),
-  promptId: z12.string(),
+  model: z17.string(),
+  promptId: z17.string(),
   /** First ~80 chars of the batch's prompt snapshot, whitespace-collapsed. */
-  promptSnippet: z12.string(),
-  batchId: z12.string(),
-  experiment: z12.string().nullable(),
-  turns: z12.number().int().nullable(),
-  usdCost: z12.number().nullable(),
-  durationMs: z12.number().int().nullable(),
-  exitReason: z12.string().nullable(),
-  createdAt: z12.string(),
-  startedAt: z12.string().nullable(),
-  finishedAt: z12.string().nullable()
+  promptSnippet: z17.string(),
+  batchId: z17.string(),
+  experiment: z17.string().nullable(),
+  turns: z17.number().int().nullable(),
+  usdCost: z17.number().nullable(),
+  durationMs: z17.number().int().nullable(),
+  exitReason: z17.string().nullable(),
+  createdAt: z17.string(),
+  startedAt: z17.string().nullable(),
+  finishedAt: z17.string().nullable()
 });
 var runListResponseSchema = listResponseSchema(runListItemSchema);
 var runDetailSchema = runListItemSchema.omit({ promptSnippet: true }).extend({
-  promptText: z12.string(),
-  attempt: z12.number().int(),
-  cancelRequested: z12.boolean(),
-  failureReason: z12.string().nullable(),
-  repoUrl: z12.string().nullable(),
-  repoRef: z12.string().nullable(),
-  scenario: z12.string(),
-  funding: z12.string(),
+  promptText: z17.string(),
+  attempt: z17.number().int(),
+  cancelRequested: z17.boolean(),
+  failureReason: z17.string().nullable(),
+  repoUrl: z17.string().nullable(),
+  repoRef: z17.string().nullable(),
+  scenario: z17.string(),
+  funding: z17.string(),
   /** Raw harness usage write-back (token counts etc.); shape may evolve. */
-  usage: z12.unknown().nullable(),
+  usage: z17.unknown().nullable(),
   /** Artifact pointer: a working-tree diff exists at GET /runs/{id}/diff. */
-  hasDiff: z12.boolean(),
-  claimedAt: z12.string().nullable()
+  hasDiff: z17.boolean(),
+  claimedAt: z17.string().nullable()
 });
-var cancelRunResponseSchema = z12.object({
-  id: z12.string(),
+var cancelRunResponseSchema = z17.object({
+  id: z17.string(),
   status: runStatusSchema,
-  cancelRequested: z12.boolean(),
-  note: z12.string().optional()
-});
-var runEventSchema = z12.looseObject({
-  run_id: z12.string(),
-  seq: z12.number(),
-  turn: z12.number(),
-  ts: z12.string(),
-  type: z12.string()
+  cancelRequested: z17.boolean(),
+  note: z17.string().optional()
+});
+var forkRunBodySchema = z17.object({
+  prompt: z17.string().trim().min(1).max(2e4),
+  turn: z17.number().int().min(0).optional()
+});
+var forkRunResponseSchema = z17.object({
+  runId: z17.string(),
+  batchId: z17.string(),
+  parentRunId: z17.string(),
+  checkpointId: z17.string(),
+  turn: z17.number().int().min(0)
+});
+var RUN_INSIGHT_STATUSES = [
+  "PENDING",
+  "RUNNING",
+  "COMPLETE",
+  "FAILED",
+  "SKIPPED"
+];
+var runInsightStatusSchema = z17.enum(RUN_INSIGHT_STATUSES);
+var insightPassSchema = z17.object({
+  status: runInsightStatusSchema,
+  model: z17.string().nullable(),
+  inputTokens: z17.number().int().nullable(),
+  outputTokens: z17.number().int().nullable(),
+  usdCost: z17.number().nullable(),
+  error: z17.string().nullable()
+});
+var runDecisionSchema = z17.object({
+  index: z17.number().int(),
+  category: z17.string(),
+  categoryRaw: z17.string().nullable(),
+  chosenName: z17.string(),
+  chosenEcosystem: z17.string().nullable(),
+  chosenPackage: z17.string().nullable(),
+  reversed: z17.boolean(),
+  detail: z17.unknown()
+});
+var runImplementationSchema = z17.object({
+  brandName: z17.string(),
+  ecosystem: z17.string().nullable(),
+  package: z17.string().nullable(),
+  verdict: z17.string(),
+  docConsulted: z17.boolean(),
+  detail: z17.unknown()
+});
+var runInsightResponseSchema = z17.object({
+  runId: z17.string(),
+  decision: insightPassSchema,
+  implementation: insightPassSchema,
+  decisions: z17.array(runDecisionSchema),
+  implementations: z17.array(runImplementationSchema)
+});
+var runEventSchema = z17.looseObject({
+  run_id: z17.string(),
+  seq: z17.number(),
+  turn: z17.number(),
+  ts: z17.string(),
+  type: z17.string()
 });
 
-// ../packages/api-schemas/src/stats.ts
-import { z as z13 } from "zod";
-var BRAND_KINDS2 = ["OWNED", "COMPETITOR", "OTHER"];
-var brandKindSchema2 = z13.enum(BRAND_KINDS2);
-var brandRankingSchema = z13.object({
-  rank: z13.number().int(),
-  brandId: z13.string(),
-  brandName: z13.string(),
-  kind: brandKindSchema2,
-  installs: z13.number().int(),
-  installRate: z13.number(),
-  mentionRate: z13.number(),
-  /** Movement between the two most recent batch windows; null if not ranked in both. */
-  deltaRank: z13.number().int().nullable()
-});
-var packageRateSchema = z13.object({
-  ecosystem: z13.string(),
-  name: z13.string(),
-  brandName: z13.string().optional(),
-  kind: brandKindSchema2.optional(),
-  installs: z13.number().int(),
-  rate: z13.number()
-});
-var brandRateSchema = z13.object({
-  brandId: z13.string(),
-  brandName: z13.string(),
-  kind: brandKindSchema2,
-  installs: z13.number().int(),
-  rate: z13.number()
-});
-var brandFunnelRowSchema = z13.object({
-  brandId: z13.string(),
-  brandName: z13.string(),
-  kind: brandKindSchema2,
-  mentionRate: z13.number(),
-  installRate: z13.number()
-});
-var domainRateSchema = z13.object({
-  domain: z13.string(),
-  runs: z13.number().int(),
-  rate: z13.number(),
-  requests: z13.number().int(),
-  deniedRequests: z13.number().int(),
-  brandName: z13.string().optional(),
-  owned: z13.boolean().optional()
-});
-var statsFreshnessSchema = z13.object({
-  /** Newest run-ingest time across the org (ISO), or null if nothing ingested. */
-  watermark: z13.string().nullable(),
-  /** Runs that succeeded recently but haven't landed in the warehouse yet. */
-  pending: z13.number().int(),
-  /** False when the freshness read itself failed (distinguish from genuine zero). */
-  available: z13.boolean()
-});
-var statsResponseSchema = (item) => z13.object({ items: z13.array(item), freshness: statsFreshnessSchema });
-var rankingsResponseSchema = statsResponseSchema(brandRankingSchema);
-var installsResponseSchema = statsResponseSchema(packageRateSchema);
-var brandsResponseSchema = statsResponseSchema(brandRateSchema);
-var funnelResponseSchema = statsResponseSchema(brandFunnelRowSchema);
-var domainsResponseSchema = statsResponseSchema(domainRateSchema);
-
 // ../packages/api-schemas/src/tokens.ts
-import { z as z14 } from "zod";
-var apiTokenSchema = z14.object({
-  id: z14.string(),
-  name: z14.string(),
+import { z as z18 } from "zod";
+var apiTokenSchema = z18.object({
+  id: z18.string(),
+  name: z18.string(),
   /** Last 4 chars of the plaintext, for recognizability (non-secret). */
-  last4: z14.string(),
-  expiresAt: z14.iso.datetime().nullable(),
-  lastUsedAt: z14.iso.datetime().nullable(),
-  createdAt: z14.iso.datetime(),
-  revokedAt: z14.iso.datetime().nullable()
-});
-var createTokenRequestSchema = z14.object({
-  name: z14.string().min(1).max(100),
+  last4: z18.string(),
+  expiresAt: z18.iso.datetime().nullable(),
+  lastUsedAt: z18.iso.datetime().nullable(),
+  createdAt: z18.iso.datetime(),
+  revokedAt: z18.iso.datetime().nullable()
+});
+var createTokenRequestSchema = z18.object({
+  name: z18.string().min(1).max(100),
   /** ISO-8601 datetime; omit for no expiry. */
-  expiresAt: z14.iso.datetime({ offset: true }).optional()
+  expiresAt: z18.iso.datetime({ offset: true }).optional()
 });
 var createTokenResponseSchema = apiTokenSchema.extend({
-  token: z14.string()
+  token: z18.string()
 });
 var listTokensResponseSchema = listResponseSchema(apiTokenSchema);
 
 // src/commands/apply.ts
-import { z as z15 } from "zod";
+import { z as z19 } from "zod";
 
 // src/version.ts
 import { createRequire } from "module";
@@ -1082,7 +1407,16 @@ var EXAMPLE_SPEC = {
       key: "migrate-to-vitest",
       text: "Migrate the test suite from Jest to Vitest.",
       scenario: "MIGRATION",
-      schedules: [{ repoUrl: "https://github.com/acme/api", repoRef: "main" }]
+      schedules: [
+        {
+          repoUrl: "https://github.com/acme/api",
+          repoRef: "main",
+          // Optional: pin a specific model id. Must be one the schedule's
+          // agent(s) can actually serve, or the run falls back to the agent
+          // default. Omit (or use null) to always use the agent default.
+          model: "claude-opus-4-8"
+        }
+      ]
     }
   ]
 };
@@ -1181,7 +1515,7 @@ function register(program2) {
   ).option("-f, --file <path>", "battery spec JSON file").option("--dry-run", "print the plan without applying").option("--schema", "print the battery spec JSON Schema and exit").option("--example", "print a minimal example battery spec and exit").action(
     async (opts, command) => {
       if (opts.schema) {
-        printJson(z15.toJSONSchema(batteries_exports.batterySpecSchema));
+        printJson(z19.toJSONSchema(batteries_exports.batterySpecSchema));
         return;
       }
       if (opts.example) {
@@ -1218,12 +1552,14 @@ function register(program2) {
 // src/commands/auth.ts
 var auth_exports = {};
 __export(auth_exports, {
+  deviceLogin: () => deviceLogin,
   register: () => register2
 });
 import { spawn } from "child_process";
 import { randomBytes } from "crypto";
 import { createServer } from "http";
 import { hostname } from "os";
+import { setTimeout as sleep } from "timers/promises";
 
 // src/lib/paginate.ts
 async function fetchAllPages(client, path, query = {}) {
@@ -1380,6 +1716,125 @@ async function browserLogin() {
     server.closeAllConnections();
   }
 }
+var DEVICE_ENDPOINT = "/api/v1/device";
+async function devicePost(path, body) {
+  const base = resolveBaseUrl().replace(/\/+$/, "");
+  let res;
+  try {
+    res = await fetch(`${base}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "User-Agent": USER_AGENT
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (e) {
+    throw new CliError(
+      "network",
+      `Request to ${base} failed: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  const text = await res.text();
+  if (!res.ok) {
+    try {
+      const parsed = errorEnvelopeSchema.safeParse(JSON.parse(text));
+      if (parsed.success) {
+        throw new CliError(parsed.data.error.code, parsed.data.error.message);
+      }
+    } catch (e) {
+      if (e instanceof CliError) throw e;
+    }
+    throw new CliError(
+      "internal",
+      `Device request failed: HTTP ${res.status} ${res.statusText}`.trim()
+    );
+  }
+  return JSON.parse(text);
+}
+async function deviceLogin(opts) {
+  const start = await devicePost(
+    `${DEVICE_ENDPOINT}/authorize`,
+    { deviceName: hostname() || "this device", email: opts.email }
+  );
+  console.log("To sign in, open this URL in a browser:\n");
+  console.log(`  ${start.verificationUriComplete}
+`);
+  console.log(`and confirm this code:  ${start.userCode}
+`);
+  if (start.emailSent && opts.email) {
+    console.log(`We also emailed a sign-in link to ${opts.email}.`);
+  }
+  console.log("Waiting for you to approve in the browser\u2026");
+  openBrowser(start.verificationUriComplete);
+  const deadline = Date.now() + start.expiresIn * 1e3;
+  const MAX_TRANSIENT = 5;
+  let interval = start.interval;
+  let transient = 0;
+  while (Date.now() < deadline) {
+    await sleep(interval * 1e3);
+    let raw;
+    try {
+      raw = await devicePost(`${DEVICE_ENDPOINT}/token`, {
+        deviceCode: start.deviceCode
+      });
+    } catch (e) {
+      if (e instanceof CliError && (e.code === "network" || e.code === "internal") && ++transient <= MAX_TRANSIENT) {
+        continue;
+      }
+      throw e;
+    }
+    transient = 0;
+    const parsed = deviceTokenResultSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new CliError(
+        "internal",
+        "Unexpected response from the device token endpoint."
+      );
+    }
+    const result = parsed.data;
+    switch (result.status) {
+      case "pending":
+        continue;
+      case "slow_down":
+        interval = result.interval;
+        continue;
+      case "denied":
+        throw new CliError(
+          "unauthorized",
+          "Authorization was denied in the browser."
+        );
+      case "expired":
+        throw new CliError(
+          "unauthorized",
+          "The sign-in request expired before it was approved. Re-run it to try again."
+        );
+      case "approved": {
+        const token = result.accessToken;
+        saveToken(token);
+        try {
+          const me = await fetchMe(new ApiClient({ token }));
+          return { token, me };
+        } catch (e) {
+          throw new CliError(
+            "network",
+            `Signed in and token saved to ${credentialsPath()}, but couldn't load your profile (${e instanceof Error ? e.message : String(e)}). Run \`gauge whoami\` to retry.`
+          );
+        }
+      }
+      default:
+        throw new CliError(
+          "internal",
+          `Unexpected device authorization status: ${result.status}`
+        );
+    }
+  }
+  throw new CliError(
+    "network",
+    "Timed out waiting for browser approval. Re-run to try again."
+  );
+}
 async function readStdin() {
   let data = "";
   for await (const chunk of process.stdin) data += chunk;
@@ -1447,10 +1902,26 @@ async function whoami(output) {
 }
 function register2(program2) {
   const auth = program2.command("auth").description("Authenticate the CLI (personal access tokens)");
-  auth.command("login").description("Log in via the browser (localhost callback flow)").option("--with-token", "read a token from stdin (headless machines)").action(async (opts) => {
-    if (opts.withToken) await withTokenLogin();
-    else await browserLogin();
-  });
+  auth.command("login").description("Log in via the browser (localhost callback flow)").option("--with-token", "read a token from stdin (headless machines)").option(
+    "--device",
+    "device-authorization flow: print a URL + code to approve elsewhere (no loopback listener; agent/remote-friendly)"
+  ).option(
+    "--email <email>",
+    "with --device: also email a sign-in link to this address"
+  ).action(
+    async (opts) => {
+      if (opts.device) {
+        const { token, me } = await deviceLogin({ email: opts.email });
+        saveToken(token);
+        console.log(`Token saved to ${credentialsPath()}`);
+        printIdentity(me);
+      } else if (opts.withToken) {
+        await withTokenLogin();
+      } else {
+        await browserLogin();
+      }
+    }
+  );
   auth.command("logout").description("Remove the stored token").action(() => {
     clearToken();
     console.log(`Removed ${credentialsPath()}`);
@@ -1926,15 +2397,95 @@ function register7(program2) {
   });
 }
 
-// src/commands/orgs.ts
-var orgs_exports = {};
-__export(orgs_exports, {
+// src/commands/onboard.ts
+var onboard_exports = {};
+__export(onboard_exports, {
   register: () => register8
 });
+function orgNameFromEmail(email) {
+  const domain = email?.split("@")[1] ?? "";
+  const base = domain.split(".")[0] ?? "";
+  if (!base) return "My Workspace";
+  return base.charAt(0).toUpperCase() + base.slice(1);
+}
+function register8(program2) {
+  program2.command("onboard").description(
+    "Self-serve onboarding: sign in (device flow) and create your first workspace"
+  ).option("--email <email>", "email a sign-in link (device-flow convenience)").option("--org-name <name>", "workspace name (default: from your email)").option("--website <url>", "company site (logo source)").option("--new", "create a new workspace even if you already belong to one").action(
+    async (opts, command) => {
+      const output = resolveOutput(command);
+      let client;
+      let me;
+      if (resolveToken()) {
+        client = new ApiClient();
+        me = await client.get("/api/v1/me");
+        if (output !== "json") {
+          console.log(`Already signed in as ${me.user.email ?? me.user.id}.`);
+        }
+      } else {
+        const login = await deviceLogin({ email: opts.email });
+        saveToken(login.token);
+        me = login.me;
+        client = new ApiClient({ token: login.token });
+        if (output !== "json") {
+          console.log(
+            `
+Signed in as ${me.user.email ?? me.user.id} \u2014 token saved to ${credentialsPath()}.`
+          );
+        }
+      }
+      const wantNewOrg = opts.new === true || opts.orgName !== void 0 || me.orgs.length === 0;
+      let orgSlug;
+      let createdOrg = null;
+      if (wantNewOrg) {
+        const name = opts.orgName?.trim() || orgNameFromEmail(me.user.email);
+        createdOrg = await client.post("/api/v1/orgs", {
+          name,
+          website: opts.website
+        });
+        orgSlug = createdOrg.slug;
+      } else {
+        orgSlug = readConfig().defaultOrg ?? me.orgs[0]?.slug ?? "";
+        if (!orgSlug) {
+          throw new CliError(
+            "internal",
+            "No workspace available; re-run with --org-name to create one."
+          );
+        }
+      }
+      updateConfig({ defaultOrg: orgSlug });
+      if (output === "json") {
+        printJson({
+          user: me.user,
+          org: createdOrg ?? { slug: orgSlug },
+          defaultOrg: orgSlug
+        });
+        return;
+      }
+      console.log(
+        createdOrg ? `
+Created workspace ${createdOrg.name} (${orgSlug}).` : `
+Using workspace ${orgSlug}.`
+      );
+      console.log(`Default org set to ${orgSlug}. You're ready:`);
+      console.log(
+        "  gauge apply --example > battery.json   # scaffold a run"
+      );
+      console.log("  gauge apply -f battery.json            # launch it");
+      console.log("  gauge runs list                        # watch results");
+    }
+  );
+}
+
+// src/commands/orgs.ts
+var orgs_exports2 = {};
+__export(orgs_exports2, {
+  register: () => register9
+});
 function isDefault(org, defaultOrg) {
   return defaultOrg !== void 0 && (org.slug === defaultOrg || org.publicId === defaultOrg);
 }
-function register8(program2) {
+function register9(program2) {
   const orgs = program2.command("orgs").description("Organizations");
   orgs.command("list").description("List orgs you belong to").action(async (_opts, command) => {
     const output = resolveOutput(command);
@@ -1959,6 +2510,23 @@ function register8(program2) {
       "table"
     );
   });
+  orgs.command("create <name>").description("Create a new LOCAL workspace and set it as the default org").option("--website <url>", "company site (used as the logo source)").option("--no-use", "don't set the new org as the default").action(
+    async (name, opts, command) => {
+      const created = await createClient().post(
+        "/api/v1/orgs",
+        { name, website: opts.website }
+      );
+      if (opts.use !== false) updateConfig({ defaultOrg: created.slug });
+      if (resolveOutput(command) === "json") {
+        printJson(created);
+        return;
+      }
+      console.log(`Created workspace ${created.name} (${created.slug})`);
+      if (opts.use !== false) {
+        console.log(`Default org set to ${created.slug}`);
+      }
+    }
+  );
   orgs.command("use <org>").description("Set the default org (slug or public id) in local config").action(async (org, _opts, command) => {
     const me = await createClient().get("/api/v1/me");
     const match = me.orgs.find((o) => o.slug === org || o.publicId === org);
@@ -1989,9 +2557,11 @@ function register8(program2) {
 var prompts_exports2 = {};
 __export(prompts_exports2, {
   parseAgents: () => parseAgents,
+  parseSamples: () => parseSamples,
   promptsPath: () => promptsPath,
   readPromptText: () => readPromptText,
-  register: () => register9,
+  readWebFixture: () => readWebFixture,
+  register: () => register10,
   resolveOrCreateTopicId: () => resolveOrCreateTopicId
 });
 import { readFileSync as readFileSync4 } from "fs";
@@ -2036,6 +2606,38 @@ function readPromptText(opts) {
   if (!text) throw new CliError("usage", "prompt file is empty");
   return text;
 }
+function readWebFixture(path) {
+  let raw;
+  try {
+    raw = readFileSync4(path, "utf8");
+  } catch (error) {
+    throw new CliError(
+      "usage",
+      "cannot read web fixture " + path + ": " + (error instanceof Error ? error.message : String(error))
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    throw new CliError(
+      "invalid_request",
+      "web fixture is not valid JSON: " + (error instanceof Error ? error.message : String(error))
+    );
+  }
+  const result = web_fixtures_exports.webFixtureSchema.safeParse(parsed);
+  if (!result.success) {
+    const details = result.error.issues.map(
+      (issue) => `  ${issue.path.join(".") || "(fixture)"}: ${issue.message}`
+    ).join("\n");
+    throw new CliError(
+      "invalid_request",
+      `not a valid web fixture:
+${details}`
+    );
+  }
+  return result.data;
+}
 async function resolveOrCreateTopicId(client, org, name) {
   const path = `/api/v1/orgs/${encodeURIComponent(org)}/topics`;
   let cursor;
@@ -2070,15 +2672,17 @@ function toRow2(p) {
     scenario: p.scenario
   };
 }
-var BLOCK_WARNINGS = {
-  insufficient_credits: "warning: prompt created, but the first run was blocked: out of credits",
-  needs_provider_key: "warning: prompt created, but the first run was blocked: no provider key for the selected agents"
-};
-var RUN_BLOCK_WARNINGS = {
-  insufficient_credits: "warning: some schedules were skipped or truncated: out of credits",
-  needs_provider_key: "warning: some schedules were skipped: no provider key for the selected agents"
-};
-function register9(program2) {
+var DEFAULT_RUN_AGENTS = ["CLAUDE_CODE", "CODEX_CLI"];
+function parseSamples(raw, max) {
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 1 || max !== void 0 && n > max)
+    throw new CliError(
+      "usage",
+      max === void 0 ? "--samples must be an integer >= 1" : `--samples must be an integer 1-${max}`
+    );
+  return n;
+}
+function register10(program2) {
   const group = program2.command("prompts").description("Manage prompts");
   group.command("list").description("List prompts").option("--topic <topic>", "filter by topic (id or name)").option("--tag <tag>", "filter by tag (id or name)").option("-q, --query <text>", "text search").action(
     async (opts, cmd) => {
@@ -2092,7 +2696,7 @@ function register9(program2) {
       else printItems(items.map(toRow2), "table");
     }
   );
-  group.command("get <id>").description("Show a prompt (schedules, topic, tags)").action(async (id, _opts, cmd) => {
+  group.command("get <id>").description("Show a prompt (scheduled-via, topic, tags)").action(async (id, _opts, cmd) => {
     const org = resolveOrg(cmd);
     const prompt = await createClient().get(
       `${promptsPath(org)}/${encodeURIComponent(id)}`
@@ -2111,20 +2715,19 @@ function register9(program2) {
     console.log(`created:  ${prompt.createdAt}`);
     console.log(`text:     ${prompt.text}`);
     if (prompt.schedules.length) {
-      console.log("schedules:");
+      console.log("scheduled via:");
       printItems(
         prompt.schedules.map((s) => ({
           id: s.id,
-          repo: s.repoUrl ?? "(default scaffold)",
-          ref: s.repoRef ?? "",
+          name: s.name,
           cadence: s.cadence,
           days: s.daysPerWeek ?? "",
-          agents: s.agents.join(", ")
+          enabled: s.enabled ? "yes" : "no"
         })),
         "table"
       );
     } else {
-      console.log("schedules: (none)");
+      console.log("scheduled via: (none)");
     }
   });
   group.command("create").description("Create a prompt").option("--text <text>", "prompt text").option("--file <path>", 'read prompt text from a file ("-" for stdin)').option("--scenario <scenario>", "greenfield | migration", "greenfield").option("--branded", "mark as a branded prompt").option("--topic <name>", "topic (created if new)").option(
@@ -2156,11 +2759,9 @@ function register9(program2) {
       else {
         console.log(`Created prompt ${created.id}`);
         console.log(
-          `No schedules yet \u2014 add one with \`gauge schedules add --prompt ${created.id} --agent claude-code\``
+          `Run it now with \`gauge prompts run ${created.id}\`, or add it to a schedule set with \`gauge schedules create --name <name> --prompt ${created.id} --agent claude-code\``
         );
       }
-      if (created.firstRunBlocked)
-        console.error(BLOCK_WARNINGS[created.firstRunBlocked]);
     }
   );
   group.command("edit <id>").description("Update a prompt").option("--text <text>", "new prompt text").option("--file <path>", 'read new text from a file ("-" for stdin)').option("--branded <bool>", "true | false").option("--topic <name>", "set the topic (created if new)").option("--clear-topic", "clear the topic").option(
@@ -2206,19 +2807,27 @@ function register9(program2) {
     );
     if (resolveOutput(cmd) !== "json") console.log(`Deleted prompt ${id}`);
   });
-  group.command("run <id>").description("Run a prompt now (ORG funding, credit-gated)").option(
+  group.command("run <id>").description(
+    "Run a prompt now \u2014 an ad-hoc agents x repo x samples spec (ORG funding, credit-gated)"
+  ).option(
     "--agent <agents>",
-    "comma-separated agents, e.g. claude-code,codex"
-  ).option("--schedule <ids>", "comma-separated schedule ids").action(
+    "comma-separated agents, e.g. claude-code,codex (default: claude-code,codex)"
+  ).option("--repo <url>", "base repo to run against (default: the scaffold)").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--samples <n>", "samples per agent, 1-10 (default: 1)").option(
+    "--web-fixture <path>",
+    "web fixture JSON; pages are injected transparently into native WebFetch (misses pass through live)"
+  ).action(
     async (id, opts, cmd) => {
       const org = resolveOrg(cmd);
-      const body = {};
-      if (opts.agent !== void 0) body.agents = parseAgents(opts.agent);
-      if (opts.schedule !== void 0) {
-        const ids = opts.schedule.split(",").map((s) => s.trim()).filter(Boolean);
-        if (ids.length === 0)
-          throw new CliError("usage", "no schedule ids given");
-        body.scheduleIds = ids;
+      if (opts.ref !== void 0 && opts.repo === void 0)
+        throw new CliError("usage", "--ref requires --repo");
+      const body = {
+        agents: opts.agent !== void 0 ? parseAgents(opts.agent) : DEFAULT_RUN_AGENTS,
+        samplesPerCycle: opts.samples !== void 0 ? parseSamples(opts.samples, 10) : 1
+      };
+      if (opts.repo !== void 0) body.repoUrl = opts.repo;
+      if (opts.ref !== void 0) body.repoRef = opts.ref;
+      if (opts.webFixture !== void 0) {
+        body.webFixture = readWebFixture(opts.webFixture);
       }
       const result = await createClient().post(
         `${promptsPath(org)}/${encodeURIComponent(id)}/run`,
@@ -2229,25 +2838,251 @@ function register9(program2) {
         return;
       }
       if (result.runIds.length === 0) {
-        console.log(
-          "No runs enqueued (the prompt has no matching schedules)"
-        );
+        console.log("No runs enqueued");
         return;
       }
       console.log(
         `Enqueued ${result.runIds.length} run(s) in ${result.batchIds.length} batch(es)`
       );
       for (const runId of result.runIds) console.log(runId);
-      if (result.blocked) console.error(RUN_BLOCK_WARNINGS[result.blocked]);
       console.error("Tip: `gauge runs watch <id>` streams a run live");
     }
   );
 }
 
+// src/commands/query.ts
+var query_exports2 = {};
+__export(query_exports2, {
+  register: () => register11
+});
+var collect3 = (value, prev = []) => [
+  ...prev,
+  value
+];
+var csv = (raw) => raw.split(",").map((s) => s.trim()).filter(Boolean);
+function parseWhere(expr) {
+  const inMatch = expr.match(/^\s*(\w+)\s+(in|contains)\s+(.*)$/i);
+  if (inMatch) {
+    const [, dimension2, opRaw, rest2] = inMatch;
+    const op = opRaw.toLowerCase();
+    if (op === "in") {
+      return { dimension: dimension2, op: "in", value: csv(rest2) };
+    }
+    return { dimension: dimension2, op: "contains", value: rest2.trim() };
+  }
+  const opMatch = expr.match(/^\s*(\w+)\s*(!=|>=|<=|=|>|<)\s*(.*)$/);
+  if (!opMatch) {
+    throw new CliError(
+      "usage",
+      `Could not parse --where "${expr}". Use e.g. "action=install", "ecosystem in npm,pypi", or "name contains supa".`
+    );
+  }
+  const [, dimension, sym, rest] = opMatch;
+  const opFor = {
+    "=": "eq",
+    "!=": "neq",
+    ">": "gt",
+    ">=": "gte",
+    "<": "lt",
+    "<=": "lte"
+  };
+  return { dimension, op: opFor[sym], value: rest.trim() };
+}
+function parseOrderBy(raw) {
+  const [key, dir] = raw.split(":");
+  return { key: key.trim(), dir: dir?.trim() === "asc" ? "asc" : "desc" };
+}
+async function readStdin2() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function buildSpec(opts) {
+  let spec = { metrics: [] };
+  if (opts.json) {
+    const raw = opts.json === "-" ? await readStdin2() : opts.json;
+    try {
+      spec = JSON.parse(raw);
+    } catch (e) {
+      throw new CliError(
+        "usage",
+        `--json is not valid JSON: ${e.message}`
+      );
+    }
+  }
+  if (opts.dataset) spec.dataset = opts.dataset;
+  if (opts.dimensions !== void 0) spec.dimensions = csv(opts.dimensions);
+  if (opts.metrics !== void 0) spec.metrics = csv(opts.metrics);
+  if (opts.where?.length) spec.where = opts.where.map(parseWhere);
+  if (opts.orderBy?.length) spec.orderBy = opts.orderBy.map(parseOrderBy);
+  if (opts.limit !== void 0) spec.limit = Number(opts.limit);
+  if (opts.granularity)
+    spec.granularity = opts.granularity;
+  if (opts.explain) spec.explain = true;
+  const date = {
+    ...spec.dateRange ?? {}
+  };
+  if (opts.since) {
+    date.since = opts.since;
+    delete date.lastDays;
+  } else if (opts.lastDays) {
+    date.lastDays = Number(opts.lastDays);
+    delete date.since;
+  }
+  if (opts.until) date.until = opts.until;
+  if (Object.keys(date).length) spec.dateRange = date;
+  if (opts.branded && opts.unbranded) {
+    throw new CliError("usage", "Pass at most one of --branded / --unbranded.");
+  }
+  const filters = {
+    ...spec.filters ?? {}
+  };
+  if (opts.prompt) filters.prompt = opts.prompt;
+  if (opts.topic) filters.topic = csv(opts.topic);
+  if (opts.tag) filters.tag = csv(opts.tag);
+  if (opts.repo) filters.repo = csv(opts.repo);
+  if (opts.language) filters.language = csv(opts.language);
+  if (opts.framework) filters.framework = csv(opts.framework);
+  if (opts.size) filters.size = csv(opts.size);
+  if (opts.agent) filters.agent = csv(opts.agent);
+  if (opts.model) filters.model = csv(opts.model);
+  if (opts.scenario) filters.scenario = csv(opts.scenario);
+  if (opts.experiment) filters.experiment = csv(opts.experiment);
+  if (opts.branded) filters.branded = true;
+  if (opts.unbranded) filters.branded = false;
+  if (Object.keys(filters).length) spec.filters = filters;
+  if (!spec.metrics || spec.metrics.length === 0) {
+    throw new CliError(
+      "usage",
+      "At least one metric is required. Pass --metrics <a,b> (or a `metrics` array in --json). See `gauge query fields --dataset <name>`."
+    );
+  }
+  return spec;
+}
+var pct = (n) => `${(n * 100).toFixed(1)}%`;
+function noteFreshness(f) {
+  if (!f.available) {
+    console.error(
+      "warning: analytics store is temporarily unavailable; results may be incomplete."
+    );
+  } else if (f.pending > 0) {
+    console.error(
+      `note: ${f.pending} recent run(s) still ingesting; results may not reflect them yet.`
+    );
+  }
+}
+async function runQuery(command, opts) {
+  const org = resolveOrg(command);
+  const output = resolveOutput(command);
+  const spec = await buildSpec(opts);
+  const res = await createClient().post(
+    `/api/v1/orgs/${encodeURIComponent(org)}/query`,
+    spec
+  );
+  if (output === "json") {
+    printJson(res);
+    return;
+  }
+  if (res.sql) console.error(`
+${res.sql}
+`);
+  const rateKeys = new Set(
+    res.columns.filter((c) => c.kind === "metric" && c.key.endsWith("_rate")).map((c) => c.key)
+  );
+  const rows = res.rows.map((row) => {
+    const out = {};
+    for (const col of res.columns) {
+      const v = row[col.key];
+      out[col.key] = rateKeys.has(col.key) && typeof v === "number" ? pct(v) : v;
+    }
+    return out;
+  });
+  printItems(
+    rows,
+    "table",
+    res.columns.map((c) => ({ key: c.key }))
+  );
+  noteFreshness(res.freshness);
+}
+async function showMetadata(command, mode, dataset) {
+  const org = resolveOrg(command);
+  const output = resolveOutput(command);
+  const meta = await createClient().get(
+    `/api/v1/orgs/${encodeURIComponent(org)}/query/metadata`
+  );
+  if (mode === "datasets") {
+    if (output === "json")
+      return printJson(
+        meta.datasets.map((d) => ({ name: d.name, grain: d.grain }))
+      );
+    printItems(
+      meta.datasets.map((d) => ({ dataset: d.name, grain: d.grain })),
+      "table"
+    );
+    return;
+  }
+  const ds = meta.datasets.find((d) => d.name === dataset);
+  if (!ds) {
+    throw new CliError(
+      "usage",
+      `Unknown dataset "${dataset}". Valid: ${meta.datasets.map((d) => d.name).join(", ")}.`
+    );
+  }
+  if (output === "json") return printJson(ds);
+  const rows = [
+    ...ds.dimensions.map((f) => ({
+      field: f.name,
+      kind: "dimension",
+      type: f.type,
+      about: f.description ?? ""
+    })),
+    ...ds.metrics.map((f) => ({
+      field: f.name,
+      kind: "metric",
+      type: f.type,
+      about: f.description ?? ""
+    }))
+  ];
+  console.error(`dataset: ${ds.name} \u2014 ${ds.grain}`);
+  printItems(rows, "table");
+}
+function register11(program2) {
+  const group = program2.command("query").description(
+    "Flexible reports over your event warehouse (run a report, or discover the catalog)"
+  );
+  group.command("run", { isDefault: true }).description("Run a report (default command)").option(
+    "--json <spec>",
+    "full query spec as JSON (or '-' to read stdin); flags override its keys"
+  ).option(
+    "--dataset <name>",
+    "runs | installs | mentions | web | network | files | tokens (default runs)"
+  ).option("-d, --dimensions <names>", "comma-separated GROUP BY dimensions").option("-m, --metrics <names>", "comma-separated metrics (at least one)").option(
+    "--where <expr>",
+    'predicate, e.g. "action=install" (repeatable)',
+    collect3
+  ).option("--since <val>", "date range start \u2014 ISO date or window (30d, 24h)").option("--until <val>", "date range end \u2014 ISO date or window").option("--last-days <n>", "shorthand for --since <n> days ago").option(
+    "--order-by <key:dir>",
+    "sort by a selected key, e.g. installs:desc (repeatable)",
+    collect3
+  ).option("--limit <n>", "max rows (default 50, max 1000)").option(
+    "--granularity <g>",
+    "date bucket: day | week | month (default day)"
+  ).option("--explain", "print the compiled SQL to stderr").option("--prompt <id>", "filter to a single prompt").option("--topic <ids>", "comma-separated topic ids").option("--tag <ids>", "comma-separated tag ids").option("--repo <urls>", "comma-separated base repo urls").option("--language <langs>", "comma-separated repo languages").option("--framework <names>", "comma-separated repo frameworks").option("--size <buckets>", "comma-separated codebase-size buckets").option("--agent <names>", "comma-separated agent names").option("--model <models>", "comma-separated models").option(
+    "--scenario <types>",
+    "comma-separated scenario types (greenfield|migration)"
+  ).option("--experiment <labels>", "comma-separated experiment labels").option("--branded", "only branded prompts").option("--unbranded", "only non-branded prompts").action((opts, command) => runQuery(command, opts));
+  group.command("datasets").description("List the datasets you can query").action(
+    (_opts, command) => showMetadata(command, "datasets")
+  );
+  group.command("fields").description("List the dimensions and metrics for a dataset").requiredOption("--dataset <name>", "dataset to describe").action(
+    (opts, command) => showMetadata(command, "fields", opts.dataset)
+  );
+}
+
 // src/commands/repos.ts
 var repos_exports2 = {};
 __export(repos_exports2, {
-  register: () => register10
+  register: () => register12
 });
 function reposPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/repos`;
@@ -2270,7 +3105,7 @@ function toRow3(repo) {
 function syncWarning(repo) {
   return `warning: GitHub metadata sync failed; retry with \`gauge repos resync ${repo.url}\``;
 }
-function register10(program2) {
+function register12(program2) {
   const repos = program2.command("repos").description("Manage repositories");
   repos.command("list").description("List repositories (yours + read-only Gauge-provided ones)").action(async (_opts, command) => {
     const org = resolveOrg(command);
@@ -2334,7 +3169,7 @@ function register10(program2) {
 // src/commands/runs.ts
 var runs_exports2 = {};
 __export(runs_exports2, {
-  register: () => register11
+  register: () => register13
 });
 function runPath(id) {
   return `/api/v1/runs/${encodeURIComponent(id)}`;
@@ -2397,6 +3232,64 @@ function detailLines(run) {
     ["Finished", run.finishedAt ?? "\u2014"]
   ];
 }
+function passLine(label, pass) {
+  const bits = [pass.status];
+  if (pass.model) bits.push(pass.model);
+  const cost = fmtUsd(pass.usdCost);
+  if (cost) bits.push(cost);
+  if (pass.error) bits.push(`error: ${compact(pass.error, 60)}`);
+  return `${label.padEnd(20)} ${bits.join("  ")}`;
+}
+function influencesVia(detail) {
+  const raw = detail?.influences;
+  if (!Array.isArray(raw)) return "";
+  const types = [];
+  for (const inf of raw) {
+    const type = inf?.type;
+    if (typeof type === "string" && !types.includes(type)) types.push(type);
+  }
+  return types.join(", ");
+}
+function printInsight(insight) {
+  console.log(passLine("Decision pass", insight.decision));
+  console.log(passLine("Implementation pass", insight.implementation));
+  console.log(`
+Decisions (${insight.decisions.length})`);
+  if (insight.decisions.length === 0) {
+    console.log(insight.decision.status === "SKIPPED" ? "(skipped)" : "(none)");
+  } else {
+    printItems(
+      insight.decisions.map((d) => ({
+        "#": d.index,
+        arena: d.category === "other" && d.categoryRaw ? d.categoryRaw : d.category,
+        chosen: d.chosenPackage ?? d.chosenName,
+        reversed: d.reversed ? "yes" : "",
+        via: influencesVia(d.detail)
+      })),
+      "table"
+    );
+  }
+  console.log(`
+Implementation quality (${insight.implementations.length})`);
+  if (insight.implementations.length === 0) {
+    console.log(
+      insight.implementation.status === "SKIPPED" ? "(skipped)" : "(none)"
+    );
+  } else {
+    printItems(
+      insight.implementations.map((it) => ({
+        verdict: it.verdict,
+        brand: it.brandName,
+        package: it.package ?? "",
+        docs: it.docConsulted ? "docs consulted" : ""
+      })),
+      "table"
+    );
+  }
+  if (insight.decisions.length > 0 || insight.implementations.length > 0) {
+    console.error("\n(full detail: rerun with -o json)");
+  }
+}
 function parseEvent(data) {
   try {
     const parsed = runEventSchema.safeParse(JSON.parse(data));
@@ -2512,7 +3405,7 @@ async function streamRun(id, json, opts) {
     if (drainTimer) clearTimeout(drainTimer);
   }
 }
-function register11(program2) {
+function register13(program2) {
   const runs = program2.command("runs").description("Inspect and manage runs");
   runs.command("list").description("List runs (newest first)").option("--status <status>", "filter by status, e.g. running,queued").option("--batch <id>", "filter by batch").option("--prompt <id>", "filter by prompt").option("--experiment <experiment>", "filter by experiment label").option("--since <window>", "e.g. 24h, 7d, or an ISO date").option("--limit <n>", "page size (1-200)", "50").option("--cursor <cursor>", "resume from a previous page's nextCursor").action(
     async (opts, command) => {
@@ -2554,6 +3447,18 @@ function register11(program2) {
       console.log(`${label.padEnd(width)}  ${value}`);
     }
   });
+  runs.command("insight <id>").description(
+    "Show the run's LLM analysis (decisions + implementation quality)"
+  ).action(async (id, _opts, command) => {
+    const insight = await createClient().get(
+      `${runPath(id)}/insight`
+    );
+    if (resolveOutput(command) === "json") {
+      printJson(insight);
+      return;
+    }
+    printInsight(insight);
+  });
   runs.command("watch <id>").description(
     "Stream normalized trace events live (SSE; exits when the run finishes)"
   ).action(async (id, _opts, command) => {
@@ -2572,8 +3477,26 @@ function register11(program2) {
   });
   runs.command("diff <id>").description("Print the run's working-tree diff to stdout").action(async (id) => {
     const diff = await createClient().get(`${runPath(id)}/diff`);
+    if (!diff) {
+      console.error("(no diff)");
+      return;
+    }
     process.stdout.write(diff);
   });
+  runs.command("fork <id>").description("Fork a finished run from its latest conversation checkpoint").requiredOption("--prompt <text>", "continuation prompt for the child run").action(async (id, opts, command) => {
+    const result = await createClient().post(
+      `${runPath(id)}/fork`,
+      { prompt: opts.prompt }
+    );
+    if (resolveOutput(command) === "json") {
+      printJson(result);
+      return;
+    }
+    console.log(
+      `Forked run ${result.runId} from ${result.parentRunId} at turn ${result.turn}`
+    );
+    console.error(`Watch it with: gauge runs watch ${result.runId}`);
+  });
   runs.command("cancel <id>").description("Request cancellation of a run").action(async (id, _opts, command) => {
     const result = await createClient().post(
       `${runPath(id)}/cancel`
@@ -2592,7 +3515,7 @@ function register11(program2) {
 // src/commands/schedules.ts
 var schedules_exports2 = {};
 __export(schedules_exports2, {
-  register: () => register12
+  register: () => register14
 });
 var CADENCE_CHOICES = [
   "none",
@@ -2617,67 +3540,138 @@ function parseDays(raw) {
     throw new CliError("usage", "--days-per-week must be an integer 1-7");
   return n;
 }
+function collect4(value, previous) {
+  return [...previous, value];
+}
+function reposLabel(repos) {
+  if (repos.length === 0) return "(default scaffold)";
+  if (repos.length === 1) {
+    const r = repos[0];
+    return r.repoRef ? `${r.repoUrl}@${r.repoRef}` : r.repoUrl;
+  }
+  return `${repos.length} repos`;
+}
+function reposFromOpts(repo, ref) {
+  return [{ repoUrl: repo, repoRef: ref ?? null }];
+}
 function toRow5(s) {
   return {
     id: s.id,
-    repo: s.repoUrl ?? "(default scaffold)",
-    ref: s.repoRef ?? "",
+    name: s.name,
     cadence: s.cadence,
     days: s.daysPerWeek ?? "",
     agents: s.agents.join(", "),
+    repos: reposLabel(s.repos),
+    prompts: s.promptCount,
+    enabled: s.enabled ? "yes" : "no",
     experiment: s.experiment ?? ""
   };
 }
-function register12(program2) {
-  const group = program2.command("schedules").description("Manage prompt schedules");
-  group.command("list").description("List schedules for a prompt").requiredOption("--prompt <id>", "prompt id").action(async (opts, cmd) => {
+function toRefRow(s) {
+  return {
+    id: s.id,
+    name: s.name,
+    cadence: s.cadence,
+    days: s.daysPerWeek ?? "",
+    enabled: s.enabled ? "yes" : "no"
+  };
+}
+var RUN_BLOCK_WARNINGS = {
+  insufficient_credits: "warning: some targets were skipped or truncated: out of credits",
+  needs_provider_key: "warning: some targets were skipped: no provider key for the selected agents"
+};
+function register14(program2) {
+  const group = program2.command("schedules").description("Manage org schedules (named prompt sets on a cadence)");
+  group.command("list").description(
+    "List schedules for the org, or (with --prompt) the schedules a prompt is in"
+  ).option("--prompt <id>", "only schedules that contain this prompt").action(async (opts, cmd) => {
     const org = resolveOrg(cmd);
-    const res = await createClient().get(
-      `${promptsPath(org)}/${encodeURIComponent(opts.prompt)}/schedules`
+    const client = createClient();
+    const json = resolveOutput(cmd) === "json";
+    if (opts.prompt !== void 0) {
+      const res2 = await client.get(
+        `${promptsPath(org)}/${encodeURIComponent(opts.prompt)}/schedules`
+      );
+      if (json) printJson(res2.items);
+      else printItems(res2.items.map(toRefRow), "table");
+      return;
+    }
+    const res = await client.get(
+      `/api/v1/orgs/${encodeURIComponent(org)}/schedules`
     );
-    if (resolveOutput(cmd) === "json") printJson(res.items);
+    if (json) printJson(res.items);
     else printItems(res.items.map(toRow5), "table");
   });
-  group.command("add").description(
-    "Add a schedule (a repo target + cadence + agents) to a prompt"
-  ).requiredOption("--prompt <id>", "prompt id").requiredOption(
+  group.command("create").description(
+    "Create an org schedule: a named prompt set + agents + cadence + repo"
+  ).requiredOption("--name <name>", "schedule name").requiredOption(
     "--agent <agents>",
     "comma-separated agents, e.g. claude-code,codex"
-  ).option("--repo <url>", "repository URL (default: the Gauge scaffold)").option("--ref <ref>", "branch, tag, or commit").option("--cadence <cadence>", CADENCE_CHOICES.join(" | "), "none").option("--days-per-week <n>", "1-7 (with --cadence days-per-week)").action(
+  ).option(
+    "--prompt <id>",
+    "member prompt id (repeatable)",
+    collect4,
+    []
+  ).option("--repo <url>", "repository URL (default: the Gauge scaffold)").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--cadence <cadence>", CADENCE_CHOICES.join(" | "), "none").option("--days-per-week <n>", "1-7 (with --cadence days-per-week)").option("--samples <n>", "samples per cycle (default: 1)").option("--model <id>", "pin a model id (default: the agent's default)").option("--disabled", "create the schedule disabled").action(
     async (opts, cmd) => {
       const org = resolveOrg(cmd);
+      if (opts.ref !== void 0 && opts.repo === void 0)
+        throw new CliError("usage", "--ref requires --repo");
       const body = {
+        name: opts.name,
         agents: parseAgents(opts.agent),
         cadence: parseCadence(opts.cadence),
-        repoUrl: opts.repo,
-        repoRef: opts.ref
+        samplesPerCycle: opts.samples !== void 0 ? parseSamples(opts.samples) : 1,
+        repos: opts.repo !== void 0 ? reposFromOpts(opts.repo, opts.ref) : [],
+        promptIds: opts.prompt,
+        enabled: !opts.disabled
       };
       if (opts.daysPerWeek !== void 0)
         body.daysPerWeek = parseDays(opts.daysPerWeek);
+      if (opts.model !== void 0) body.model = opts.model;
       const schedule = await createClient().post(
-        `${promptsPath(org)}/${encodeURIComponent(opts.prompt)}/schedules`,
+        `/api/v1/orgs/${encodeURIComponent(org)}/schedules`,
         body
       );
       if (resolveOutput(cmd) === "json") printJson(schedule);
-      else console.log(`Added schedule ${schedule.id}`);
+      else console.log(`Created schedule ${schedule.id}`);
     }
   );
-  group.command("edit <id>").description("Update a schedule").option("--agent <agents>", "comma-separated agents").option("--repo <url>", "repository URL").option("--clear-repo", "reset to the default scaffold").option("--ref <ref>", "branch, tag, or commit").option("--clear-ref", "reset to the repo's default branch").option("--cadence <cadence>", CADENCE_CHOICES.join(" | ")).option("--days-per-week <n>", "1-7 (with cadence days-per-week)").action(
+  group.command("edit <id>").description("Update a schedule (repos and prompts are full replacements)").option("--name <name>", "rename the schedule").option("--agent <agents>", "comma-separated agents").option(
+    "--prompt <id>",
+    "member prompt id \u2014 replaces the whole set (repeatable)",
+    collect4,
+    []
+  ).option("--clear-prompts", "remove all member prompts").option("--repo <url>", "set a single repo target").option("--ref <ref>", "branch, tag, or commit (with --repo)").option("--clear-repos", "reset to the default scaffold (no repos)").option("--cadence <cadence>", CADENCE_CHOICES.join(" | ")).option("--days-per-week <n>", "1-7 (with cadence days-per-week)").option("--samples <n>", "samples per cycle").option("--model <id>", "pin a model id").option("--clear-model", "use the agent's default model").option("--enable", "enable the schedule").option("--disable", "disable the schedule").action(
     async (id, opts, cmd) => {
       const body = {};
+      if (opts.name !== void 0) body.name = opts.name;
       if (opts.agent !== void 0) body.agents = parseAgents(opts.agent);
-      if (opts.repo !== void 0 && opts.clearRepo)
-        throw new CliError("usage", "--repo and --clear-repo conflict");
-      if (opts.clearRepo) body.repoUrl = null;
-      else if (opts.repo !== void 0) body.repoUrl = opts.repo;
-      if (opts.ref !== void 0 && opts.clearRef)
-        throw new CliError("usage", "--ref and --clear-ref conflict");
-      if (opts.clearRef) body.repoRef = null;
-      else if (opts.ref !== void 0) body.repoRef = opts.ref;
       if (opts.cadence !== void 0)
         body.cadence = parseCadence(opts.cadence);
       if (opts.daysPerWeek !== void 0)
         body.daysPerWeek = parseDays(opts.daysPerWeek);
+      if (opts.samples !== void 0)
+        body.samplesPerCycle = parseSamples(opts.samples);
+      if (opts.model !== void 0 && opts.clearModel)
+        throw new CliError("usage", "--model and --clear-model conflict");
+      if (opts.clearModel) body.model = null;
+      else if (opts.model !== void 0) body.model = opts.model;
+      if (opts.ref !== void 0 && opts.repo === void 0)
+        throw new CliError("usage", "--ref requires --repo");
+      if (opts.repo !== void 0 && opts.clearRepos)
+        throw new CliError("usage", "--repo and --clear-repos conflict");
+      if (opts.clearRepos) body.repos = [];
+      else if (opts.repo !== void 0)
+        body.repos = reposFromOpts(opts.repo, opts.ref);
+      if (opts.prompt.length > 0 && opts.clearPrompts)
+        throw new CliError("usage", "--prompt and --clear-prompts conflict");
+      if (opts.clearPrompts) body.promptIds = [];
+      else if (opts.prompt.length > 0) body.promptIds = opts.prompt;
+      if (opts.enable && opts.disable)
+        throw new CliError("usage", "--enable and --disable conflict");
+      if (opts.enable) body.enabled = true;
+      else if (opts.disable) body.enabled = false;
       if (Object.keys(body).length === 0)
         throw new CliError("usage", "nothing to change");
       const schedule = await createClient().patch(
@@ -2688,6 +3682,32 @@ function register12(program2) {
       else console.log(`Updated schedule ${schedule.id}`);
     }
   );
+  group.command("run <id>").description(
+    "Run a schedule now \u2014 forced expansion of its whole member set (ORG funding, credit-gated)"
+  ).action(async (id, _opts, cmd) => {
+    const result = await createClient().post(
+      `/api/v1/schedules/${encodeURIComponent(id)}/run`,
+      {}
+    );
+    if (resolveOutput(cmd) === "json") {
+      printJson(result);
+      return;
+    }
+    if (result.runIds.length === 0) {
+      console.log("No runs enqueued (the schedule has no member prompts)");
+      return;
+    }
+    console.log(
+      `Enqueued ${result.runIds.length} run(s) in ${result.batchIds.length} batch(es)`
+    );
+    for (const runId of result.runIds) console.log(runId);
+    if (result.blocked) console.error(RUN_BLOCK_WARNINGS[result.blocked]);
+    for (const nr of result.notReady ?? [])
+      console.error(
+        `warning: skipped ${nr.repoUrl} \u2014 baseline snapshot ${nr.status}`
+      );
+    console.error("Tip: `gauge runs watch <id>` streams a run live");
+  });
   group.command("rm <id>").description("Delete a schedule").action(async (id, _opts, cmd) => {
     await createClient().delete(
       `/api/v1/schedules/${encodeURIComponent(id)}`
@@ -2699,7 +3719,7 @@ function register12(program2) {
 // src/commands/stats.ts
 var stats_exports2 = {};
 __export(stats_exports2, {
-  register: () => register13
+  register: () => register15
 });
 function addFilterOptions(cmd) {
   return cmd.option("--prompt <id>", "filter to a single prompt").option("--topic <ids>", "comma-separated topic ids").option("--tag <ids>", "comma-separated tag ids").option("--repo <urls>", "comma-separated base repo urls").option("--language <langs>", "comma-separated repo languages").option("--framework <names>", "comma-separated repo frameworks").option("--size <buckets>", "comma-separated codebase-size buckets").option("--branded", "only branded prompts").option("--unbranded", "only non-branded prompts").option("--limit <n>", "max rows (default 50)").option("--full", "return all rows (up to 1000)");
@@ -2720,9 +3740,9 @@ function filterQuery(opts) {
     limit: opts.full ? "1000" : opts.limit
   };
 }
-var pct = (rate) => `${(rate * 100).toFixed(1)}%`;
+var pct2 = (rate) => `${(rate * 100).toFixed(1)}%`;
 var delta = (d) => d === null || d === 0 ? "\u2014" : d > 0 ? `+${d}` : String(d);
-function noteFreshness(f) {
+function noteFreshness2(f) {
   if (!f.available) {
     console.error(
       "warning: analytics store is temporarily unavailable; results may be incomplete."
@@ -2745,15 +3765,15 @@ async function runStats(command, resource, opts, toRow6) {
     return;
   }
   printItems(res.items.map(toRow6), "table");
-  noteFreshness(res.freshness);
+  noteFreshness2(res.freshness);
 }
 var rankingRow = (r) => ({
   rank: r.rank,
   brand: r.brandName,
   kind: r.kind,
   installs: r.installs,
-  "install%": pct(r.installRate),
-  "mention%": pct(r.mentionRate),
+  "install%": pct2(r.installRate),
+  "mention%": pct2(r.mentionRate),
   delta: delta(r.deltaRank)
 });
 var packageRow = (r) => ({
@@ -2762,29 +3782,28 @@ var packageRow = (r) => ({
   brand: r.brandName,
   kind: r.kind,
   installs: r.installs,
-  rate: pct(r.rate)
+  rate: pct2(r.rate)
 });
 var brandRow = (r) => ({
   brand: r.brandName,
   kind: r.kind,
   installs: r.installs,
-  rate: pct(r.rate)
+  rate: pct2(r.rate)
 });
 var funnelRow = (r) => ({
   brand: r.brandName,
   kind: r.kind,
-  "mention%": pct(r.mentionRate),
-  "install%": pct(r.installRate)
+  "mention%": pct2(r.mentionRate),
+  "install%": pct2(r.installRate)
 });
 var domainRow = (r) => ({
   domain: r.domain,
   brand: r.brandName,
   runs: r.runs,
-  rate: pct(r.rate),
-  requests: r.requests,
-  denied: r.deniedRequests
+  rate: pct2(r.rate),
+  requests: r.requests
 });
-function register13(program2) {
+function register15(program2) {
   const group = program2.command("stats").description("Read-only analytics over your runs");
   addFilterOptions(
     group.command("rankings").description("Brands ranked by install rate")
@@ -2816,12 +3835,12 @@ function register13(program2) {
 // src/commands/tags.ts
 var tags_exports2 = {};
 __export(tags_exports2, {
-  register: () => register14
+  register: () => register16
 });
 function tagsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/tags`;
 }
-function register14(program2) {
+function register16(program2) {
   const group = program2.command("tags").description("Manage org tags");
   group.command("list").description("List tags").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -2864,12 +3883,12 @@ function register14(program2) {
 // src/commands/topics.ts
 var topics_exports2 = {};
 __export(topics_exports2, {
-  register: () => register15
+  register: () => register17
 });
 function topicsPath(org) {
   return `/api/v1/orgs/${encodeURIComponent(org)}/topics`;
 }
-function register15(program2) {
+function register17(program2) {
   const group = program2.command("topics").description("Manage org topics");
   group.command("list").description("List topics").action(async (_opts, cmd) => {
     const org = resolveOrg(cmd);
@@ -2890,9 +3909,9 @@ function register15(program2) {
 // src/commands/usage.ts
 var usage_exports = {};
 __export(usage_exports, {
-  register: () => register16
+  register: () => register18
 });
-function register16(program2) {
+function register18(program2) {
   program2.command("usage").description("List credit ledger entries").option("--since <window>", 'e.g. "30d", "24h", or an ISO date').option("--limit <n>", "page size (1-200)", parseLimit, 50).option("--cursor <cursor>", "resume from a previous page's nextCursor").action(
     async (opts, cmd) => {
       const org = resolveOrg(cmd);
@@ -2948,7 +3967,8 @@ program.name("gauge").description(
 );
 for (const group of [
   auth_exports,
-  orgs_exports,
+  onboard_exports,
+  orgs_exports2,
   prompts_exports2,
   schedules_exports2,
   repos_exports2,
@@ -2962,6 +3982,7 @@ for (const group of [
   billing_exports2,
   usage_exports,
   stats_exports2,
+  query_exports2,
   config_exports
 ]) {
   group.register(program);