@desplega.ai/agent-swarm 2.4.0 → 2.4.1

package/src/http/ranking.ts

@@ -3,13 +3,9 @@ import { z } from "zod";
 import { getDbClient, upsertSwarmConfig } from "../be/db";
 import {
   buildListing,
-  mintRankingClaim,
   PUBLIC_RANKING_ENABLED_KEY,
   RANKING_CATEGORIES,
-  rankingEntryFile,
   rankingFormSchema,
-  rankingLeaveUrl,
-  rankingPrUrl,
   readTelemetryRanking,
   TELEMETRY_RANKING_KEY,
   type TelemetryRanking,
@@ -23,14 +19,14 @@ import {
 } from "../utils/org-identity";
 import { ensureConfigAdmin } from "./config";
 import { scheduleIntegrationsReload } from "./core";
+import { globalConfig } from "./global-config";
 import { route } from "./route-def";
-import { globalConfig, telemetryProxyEndpoint } from "./used-by";
+import { telemetryProxyEndpoint } from "./used-by";
 
 // ─── Schemas ─────────────────────────────────────────────────────────────────
 
 const ListingSchema = z.object({
   v: z.literal(1),
-  claim: z.string(),
   name: z.string(),
   domain: z.string(),
   category: z.enum(RANKING_CATEGORIES),
@@ -49,26 +45,21 @@ const RankingStateSchema = z.object({
   name: z.string().nullable(),
   domain: z.string().nullable(),
   listing: ListingSchema.nullable(),
-  /** False when the stored listing was built for another website: a new PR is needed. */
+  /** False when the stored listing was built for another website: Get ranked again. */
   listingMatchesDomain: z.boolean(),
-  fileJson: z.string().nullable(),
-  prUrl: z.string().nullable(),
+  /** The proxy page that checks whether the domain would be ranked. */
   verifyUrl: z.string().nullable(),
 });
 export type RankingState = z.infer<typeof RankingStateSchema>;
 
 const OptInResponseSchema = z.object({
   domain: z.string(),
-  claim: z.string(),
   listing: ListingSchema,
-  fileJson: z.string(),
-  prUrl: z.string(),
   verifyUrl: z.string(),
 });
 
 const OptOutResponseSchema = z.object({
   enabled: z.literal(false),
-  leaveUrl: z.string().nullable(),
 });
 
 // ─── Route Definitions ───────────────────────────────────────────────────────
@@ -79,7 +70,7 @@ const getRanking = route({
   pattern: ["api", "ranking"],
   summary: "Public ranking state",
   description:
-    "Whether this install can join the public agent-swarm.dev ranking (telemetry on, organization name and website set), whether it is opted in, and its stored listing. The listing carries the private ranking claim, so only a config admin can read it.",
+    "Whether this install can join the public agent-swarm.dev ranking (telemetry on, organization name and website set), whether it is opted in, and its stored listing. Only a config admin can read it.",
   tags: ["Telemetry"],
   responses: {
     200: { description: "Ranking state", schema: RankingStateSchema },
@@ -95,7 +86,7 @@ const optIn = route({
   pattern: ["api", "ranking", "opt-in"],
   summary: "Opt this install into the public ranking",
   description:
-    "Builds the telemetry_ranking listing from the organization name and website plus the chosen category, stores it, turns PUBLIC_RANKING_ENABLED on and sends ranking.opted_in. The install is ranked only after a ranking PR with the returned file is merged into desplega-ai/agent-swarm.",
+    "Builds the telemetry_ranking listing from the organization name and website plus the chosen category, stores it, turns PUBLIC_RANKING_ENABLED on and sends ranking.opted_in. That is the whole opt-in: the install shows on agent-swarm.dev/ranking at the next hourly refresh.",
   tags: ["Telemetry"],
   body: rankingFormSchema,
   responses: {
@@ -117,7 +108,7 @@ const optOut = route({
   pattern: ["api", "ranking", "opt-out"],
   summary: "Leave the public ranking",
   description:
-    "Turns PUBLIC_RANKING_ENABLED off and sends ranking.opted_out, so workers stop sending ranking.usage. Returns the GitHub page that deletes the ranking entry.",
+    "Turns PUBLIC_RANKING_ENABLED off and sends ranking.opted_out, so workers stop sending ranking.usage. The install leaves agent-swarm.dev/ranking at the next hourly refresh.",
   tags: ["Telemetry"],
   responses: {
     200: { description: "Opted out", schema: OptOutResponseSchema },
@@ -163,11 +154,17 @@ async function telemetryReady(): Promise<boolean> {
   return isTelemetryEnabled() && Boolean(await globalConfig("telemetry_installation_id"));
 }
 
-async function verifyUrl(listing: Pick<TelemetryRanking, "domain" | "claim">): Promise<string> {
-  const params = new URLSearchParams({ domain: listing.domain, claim: listing.claim });
+async function verifyUrl(domain: string): Promise<string> {
+  const params = new URLSearchParams({ domain });
   return `${await telemetryProxyEndpoint("/v1/ranking/verify")}?${params.toString()}`;
 }
 
+/** The listing without the claim a v2.4.0 opt-in stored. */
+function withoutClaim(listing: TelemetryRanking): Omit<TelemetryRanking, "claim"> {
+  const { claim: _claim, ...rest } = listing;
+  return rest;
+}
+
 async function setEnabled(enabled: boolean): Promise<void> {
   await upsertSwarmConfig({
     scope: "global",
@@ -179,7 +176,7 @@ async function setEnabled(enabled: boolean): Promise<void> {
 function emitOptedIn(listing: TelemetryRanking): void {
   telemetry.ranking(
     "opted_in",
-    { listing: JSON.stringify(listing) },
+    { listing: JSON.stringify(withoutClaim(listing)) },
     { orgName: listing.name, orgWebsite: listing.domain },
   );
 }
@@ -204,17 +201,15 @@ export async function buildRankingState(): Promise<RankingState> {
     enabled: enabled && listingMatchesDomain,
     name: identity.name,
     domain: identity.website,
-    listing,
+    listing: listing ? withoutClaim(listing) : null,
     listingMatchesDomain,
-    fileJson: current ? rankingEntryFile(current) : null,
-    prUrl: current ? rankingPrUrl(current) : null,
-    verifyUrl: current ? await verifyUrl(current) : null,
+    verifyUrl: current ? await verifyUrl(current.domain) : null,
   };
 }
 
 /**
  * Keep the listing in step with the org identity after a global config write.
- * A renamed org rebuilds the listing with the same claim and re-sends it; a
+ * A renamed org rebuilds the listing and re-sends it; a
  * cleared or placeholder name, a changed or cleared website, or the setting
  * turned off by hand opts the install out.
  */
@@ -238,7 +233,7 @@ export async function syncRankingAfterConfigChange(
   if (identity.ok && identity.website === listing.domain) {
     if (identity.name === listing.name) return;
     try {
-      rebuilt = buildListing(identity, listing, listing.claim);
+      rebuilt = buildListing(identity, listing);
     } catch {
       // A name the listing cannot carry (over 60 characters) leaves the ranking.
     }
@@ -272,7 +267,6 @@ export async function handleRanking(
   if (getRanking.match(req.method, pathSegments)) {
     const parsed = await getRanking.parse(req, res, pathSegments, queryParams);
     if (!parsed) return true;
-    // The state carries the claim and the PR that proves ownership of the listing.
     if (!(await ensureConfigAdmin(req, res, "config.write.any"))) return true;
     getRanking.respond(res, 200, await buildRankingState());
     return true;
@@ -300,16 +294,12 @@ export async function handleRanking(
       return true;
     }
 
-    const website = identity.website;
     const db = getDbClient();
-    // Read the stored claim under the write lock: two concurrent first opt-ins
-    // must return the same claim, or the one merged into community/ranking is lost.
+    // The listing and the flag land together, and the event fires only after both commit.
     const built = await db.transaction(async () => {
-      const stored = await storedListing();
-      const claim = stored?.domain === website ? stored.claim : mintRankingClaim();
       let listing: TelemetryRanking;
       try {
-        listing = buildListing(identity, parsed.body, claim);
+        listing = buildListing(identity, parsed.body);
       } catch (error) {
         return { ok: false as const, error };
       }
@@ -339,11 +329,8 @@ export async function handleRanking(
 
     optIn.respond(res, 200, {
       domain: listing.domain,
-      claim: listing.claim,
       listing,
-      fileJson: rankingEntryFile(listing),
-      prUrl: rankingPrUrl(listing),
-      verifyUrl: await verifyUrl(listing),
+      verifyUrl: await verifyUrl(listing.domain),
     });
     return true;
   }
@@ -356,10 +343,7 @@ export async function handleRanking(
     await setEnabled(false);
     if (listing) emitOptedOut(listing.domain);
     scheduleIntegrationsReload();
-    optOut.respond(res, 200, {
-      enabled: false,
-      leaveUrl: listing ? rankingLeaveUrl(listing.domain) : null,
-    });
+    optOut.respond(res, 200, { enabled: false });
     return true;
   }
 

package/src/http/tasks.ts

@@ -73,6 +73,7 @@ import {
   SteeringSourceSchema,
   SteerModeSchema,
   SteerResultSchema,
+  SUPERSEDED_WORKFLOW_TASK_REASON,
   splitLegacyModelAlias,
   TaskAttachmentSchema,
 } from "../types";
@@ -2014,7 +2015,7 @@ export async function handleTasks(
     // Check this BEFORE the supersede UPDATE so we don't leave a workflow
     // step in `superseded` if the engine expects `failed`.
     if (task.workflowRunStepId != null) {
-      const failed = await failTask(parsed.params.id, "superseded_workflow_task");
+      const failed = await failTask(parsed.params.id, SUPERSEDED_WORKFLOW_TASK_REASON);
       ensure({
         id: "task.workflow_step_failed_on_supersede",
         flow: "task",

package/src/http/telemetry-ui.ts

@@ -43,7 +43,7 @@ const enableTelemetry = route({
   description:
     "Stores `ANONYMIZED_TELEMETRY=true` and applies it to the running server: the install ID is minted if needed and `telemetry.enabled` is sent once, so no restart is needed.",
   tags: ["Telemetry"],
-  body: z.object({ via: z.enum(["banner", "settings"]).default("banner") }),
+  body: z.object({ via: z.enum(["banner", "settings", "benchmark"]).default("banner") }),
   responses: {
     200: {
       description: "Telemetry is on",

package/src/http/used-by.ts

@@ -1,12 +1,14 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { z } from "zod";
-import { getSwarmConfigs, upsertSwarmConfig } from "../be/db";
+import { getDbClient, upsertSwarmConfig } from "../be/db";
 import { isTelemetryEnabled, trackRelayed } from "../telemetry";
+import { USER_FUNCTIONS } from "../utils/company-profile";
 import { orgIdentityStatus } from "../utils/org-identity";
 import { normalizeOrgWebsite, TELEMETRY_PROXY_ORIGIN } from "../utils/org-website";
 import { ensureConfigAdmin } from "./config";
 import { scheduleIntegrationsReload } from "./core";
 import { resolveHttpFavoriteOwner } from "./favorite-owner";
+import { globalConfig } from "./global-config";
 import { route } from "./route-def";
 import { jsonError } from "./utils";
 
@@ -16,6 +18,9 @@ const CONSENT_AT_KEY = "SWARM_USED_BY_CONSENT_AT";
 // still reaches the proxy after the name or website is changed or cleared.
 const GRANTED_NAME_KEY = "SWARM_USED_BY_ORG_NAME";
 const GRANTED_WEBSITE_KEY = "SWARM_USED_BY_ORG_WEBSITE";
+const CONTACT_EMAIL_KEY = "SWARM_USED_BY_CONTACT_EMAIL";
+const CONTACT_FUNCTION_KEY = "SWARM_USED_BY_CONTACT_FUNCTION";
+const QUOTE_KEY = "SWARM_USED_BY_QUOTE";
 const TIMEOUT_MS = 10_000;
 
 // ─── Route Definitions ───────────────────────────────────────────────────────
@@ -26,17 +31,30 @@ const usedBy = route({
   pattern: ["api", "used-by"],
   summary: "Grant or revoke the 'used by' logo consent",
   description:
-    "Records whether agent-swarm.dev may show this organization's logo as a company that uses Agent Swarm. Sends the organization name and website to the telemetry proxy, where a person approves each logo by hand. An explicit admin action, so it is not gated by the telemetry opt-out.",
+    "Records consent to show the organization's logo on agent-swarm.dev. A grant requires a valid contact email. It sends organization identity, contact details, and an optional quote to the proxy for manual review. This explicit admin action works when telemetry is off. A revoke clears the stored contact details and quote.",
   tags: ["Telemetry"],
-  body: z.object({ granted: z.boolean() }),
+  body: z
+    .object({
+      granted: z.boolean(),
+      contactEmail: z
+        .string()
+        .max(320, "Contact email must be at most 320 characters")
+        .email("Contact email must be a valid email address")
+        .optional(),
+      contactFunction: z.enum(USER_FUNCTIONS).optional(),
+      quote: z.string().max(280).optional(),
+    })
+    .refine((body) => !body.granted || body.contactEmail !== undefined, {
+      path: ["contactEmail"],
+      message: "Contact email is required when granting logo consent",
+    }),
   responses: {
     200: {
       description: "Consent recorded",
       schema: z.object({ granted: z.boolean(), changedAt: z.string() }),
     },
     400: {
-      description:
-        "Organization name or website is not set (a revoke falls back to the identity of the last grant)",
+      description: "Invalid contact details, or missing organization name or website",
     },
     401: { description: "Unauthorized" },
     403: { description: "Only a config admin can change the consent" },
@@ -47,12 +65,6 @@ const usedBy = route({
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
-/** A global config value, falling back to the process env. */
-export async function globalConfig(key: string): Promise<string | undefined> {
-  const stored = (await getSwarmConfigs({ scope: "global", key }))?.[0]?.value?.trim();
-  return stored || process.env[key]?.trim() || undefined;
-}
-
 /** A proxy path next to the configured `/v1/feedback` endpoint, so a stubbed proxy gets every route. */
 export async function telemetryProxyEndpoint(path: `/v1/${string}`): Promise<string> {
   const feedback = await globalConfig("feedback_endpoint");
@@ -80,7 +92,7 @@ export async function handleUsedBy(
   if (!parsed) return true;
   if (!(await ensureConfigAdmin(req, res, "config.write.any"))) return true;
 
-  const { granted } = parsed.body;
+  const { granted, contactEmail, contactFunction, quote } = parsed.body;
   // The shared identity reader. The grant keeps its own rule (any non-empty
   // name), so it does not apply the ranking's placeholder-name check.
   const current = orgIdentityStatus({
@@ -116,6 +128,9 @@ export async function handleUsedBy(
         org_website: orgWebsite,
         ...(orgDomain ? { org_domain: orgDomain } : {}),
         granted,
+        ...(granted
+          ? { contact_email: contactEmail, contact_function: contactFunction, quote }
+          : {}),
         changed_at: changedAt,
       }),
       signal: AbortSignal.timeout(TIMEOUT_MS),
@@ -129,18 +144,39 @@ export async function handleUsedBy(
     return true;
   }
 
-  await upsertSwarmConfig({ scope: "global", key: CONSENT_KEY, value: String(granted) });
-  await upsertSwarmConfig({ scope: "global", key: CONSENT_AT_KEY, value: changedAt });
-  if (granted) {
-    await upsertSwarmConfig({ scope: "global", key: GRANTED_NAME_KEY, value: orgName });
-    await upsertSwarmConfig({ scope: "global", key: GRANTED_WEBSITE_KEY, value: orgWebsite });
-  }
+  await getDbClient().transaction(async () => {
+    await upsertSwarmConfig({ scope: "global", key: CONSENT_KEY, value: String(granted) });
+    await upsertSwarmConfig({ scope: "global", key: CONSENT_AT_KEY, value: changedAt });
+    if (granted) {
+      await upsertSwarmConfig({ scope: "global", key: GRANTED_NAME_KEY, value: orgName });
+      await upsertSwarmConfig({ scope: "global", key: GRANTED_WEBSITE_KEY, value: orgWebsite });
+    }
+    // Contact details stay out of agent env. The email is also a secret row,
+    // so `GET /api/config` masks it for every reader.
+    for (const [key, value, isSecret] of [
+      [CONTACT_EMAIL_KEY, contactEmail, true],
+      [CONTACT_FUNCTION_KEY, contactFunction, false],
+      [QUOTE_KEY, quote, false],
+    ] as const) {
+      await upsertSwarmConfig({
+        scope: "global",
+        key,
+        value: granted ? (value ?? "") : "",
+        isSecret,
+        exportToEnv: false,
+      });
+    }
+  });
   scheduleIntegrationsReload();
 
   const owner = await resolveHttpFavoriteOwner(req, myAgentId);
   trackRelayed(
     "used_by.consent_changed",
-    { granted },
+    {
+      granted,
+      has_quote: granted && Boolean(quote),
+      has_function: granted && Boolean(contactFunction),
+    },
     { actor: owner?.userId ? { userId: owner.userId } : undefined, emitter: "ui" },
   );
   usedBy.respond(res, 200, { granted, changedAt });

package/src/http/users.ts

@@ -205,7 +205,7 @@ const createUserRoute = route({
   tags: ["Users"],
   body: z.object({
     name: z.string().min(1),
-    email: z.string().optional(),
+    email: z.string().email("Email must be a valid email address").optional(),
     role: z.string().optional(),
     notes: z.string().optional(),
     emailAliases: z.array(z.string()).optional(),
@@ -307,7 +307,7 @@ const updateUserRoute = route({
   body: z
     .object({
       name: z.string().min(1).optional(),
-      email: z.string().optional(),
+      email: z.string().email("Email must be a valid email address").nullable().optional(),
       role: z.string().optional(),
       notes: z.string().optional(),
       emailAliases: z.array(z.string()).optional(),

package/src/providers/amp-adapter.ts

@@ -44,7 +44,7 @@ import type {
  * default; the image installs exactly this version and the per-task settings
  * set `amp.updates.mode: "disabled"`. Bump it deliberately, with a live run.
  */
-export const AMP_PACKAGE = "@ampcode/cli@0.0.1792324855-g9c86a5";
+export const AMP_PACKAGE = "@ampcode/cli@0.0.1792368068-g91990d";
 
 /** MCP server name. Amp exposes its tools as `agent_swarm` / `store_progress` (dashes become underscores). */
 const AMP_MCP_SERVER_NAME = "agent-swarm";

package/src/providers/pi-mono-adapter.ts

@@ -115,6 +115,7 @@ function modelToCredKeys(modelStr: string | undefined): string[] | null {
     if (provider === "openrouter") return ["OPENROUTER_API_KEY"];
     if (provider === "openai") return ["OPENAI_API_KEY"];
     if (provider === "google") return ["GOOGLE_API_KEY", "GEMINI_API_KEY"];
+    if (provider === "opencode-go") return ["OPENCODE_API_KEY"];
     // models.json custom providers (`writeSessionModelsJson`). The
     // runner normalizes key aliases (HELMCODE_API_NAN → NAN_API_KEY), but a
     // worker without that step (or a boot-time check) may only see the alias.
@@ -145,6 +146,19 @@ function getHarnessDrivableBedrockModels(): Array<{ id: string; name: string }>
   }
 }
 
+/**
+ * The `opencode-go` model ids this pi-ai build resolves. models.dev can list
+ * ids pi-ai does not know yet, and pi runs its default model for those, so the
+ * worker reports this list and the picker offers only these ids.
+ */
+export function listPiOpencodeGoModelIds(): string[] {
+  try {
+    return getModels("opencode-go").map((m) => m.id);
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Enumerate the Bedrock models that are both invocable by this AWS account and
  * drivable by the pi-ai Converse harness, and verify the credential chain in
@@ -480,6 +494,7 @@ const PI_RUNTIME_API_KEYS: readonly (readonly [envKey: string, provider: string]
   ["OPENAI_API_KEY", "openai"],
   ["GEMINI_API_KEY", "google"],
   ["GOOGLE_API_KEY", "google"],
+  ["OPENCODE_API_KEY", "opencode-go"],
   // models.json custom providers (the registry). A runtime key beats the
   // file's `apiKey: "$NAN_API_KEY"`, which pi would otherwise read from the
   // shared process.env, where a credential pool is still the raw comma list.

package/src/providers/reasoning-effort.ts

@@ -168,7 +168,8 @@ function buildOpencodeReasoningOptions(
     // qualitative level — translate internally (see "What We're NOT Doing" in
     // the plan: no numeric budget surface for operators, only this
     // adapter-internal transport detail).
-    if (level === "max") return { reasoningEffort: level };
+    // Its Anthropic transport reads `effort` into `output_config.effort`.
+    if (level === "max") return { effort: level };
     return { thinking: { type: "enabled", budgetTokens: ANTHROPIC_BUDGET_TOKENS_BY_LEVEL[level] } };
   }
   if (providerId === "openrouter") {

package/src/providers/types.ts

@@ -320,6 +320,8 @@ export interface CredStatus {
    * string signals Bedrock mode with `AWS_REGION` unset (no region fabricated).
    */
   bedrockRegion?: string;
+  /** Pi-mono only: the `opencode-go` model ids pi-ai resolves. Undefined for other harnesses. */
+  opencodeGoModels?: string[];
 }
 
 /**

package/src/ranking/telemetry-ranking.ts

@@ -23,8 +23,6 @@ export const RANKING_CATEGORIES = Object.keys(RANKING_TAXONOMY) as [
   keyof typeof RANKING_TAXONOMY,
   ...(keyof typeof RANKING_TAXONOMY)[],
 ];
-export const RANKING_CLAIM_PATTERN = /^rk_[0-9a-f]{32}$/;
-
 const hostname = z.string().refine((v) => normalizeOrgWebsite(v) === v, "bare hostname");
 const nullableText = (max: number) => z.string().trim().min(1).max(max).nullable();
 
@@ -37,7 +35,11 @@ function inCategory(category: string, subcategory: string | null): boolean {
 export const telemetryRankingV1 = z
   .strictObject({
     v: z.literal(1),
-    claim: z.string().regex(RANKING_CLAIM_PATTERN),
+    /** Minted by v2.4.0 for the retired ranking PR. Still parsed, never written; the proxy ignores it. */
+    claim: z
+      .string()
+      .regex(/^rk_[0-9a-f]{32}$/)
+      .optional(),
     name: z.string().trim().min(1).max(60),
     domain: hostname,
     category: z.enum(RANKING_CATEGORIES),
@@ -88,12 +90,6 @@ export const rankingFormSchema = z.object({
 });
 export type RankingForm = z.infer<typeof rankingFormSchema>;
 
-/** `rk_` + 32 lowercase hex characters from the platform CSPRNG. */
-export function mintRankingClaim(): string {
-  const bytes = crypto.getRandomValues(new Uint8Array(16));
-  return `rk_${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
-}
-
 const blankToNull = (value: string | null | undefined) => value?.trim() || null;
 
 /**
@@ -104,7 +100,6 @@ const blankToNull = (value: string | null | undefined) => value?.trim() || null;
 export function buildListing(
   identity: OrgIdentityStatus,
   form: RankingForm,
-  claim: string,
   now: Date = new Date(),
 ): TelemetryRanking {
   if (!identity.ok || !identity.name || !identity.website) {
@@ -112,7 +107,6 @@ export function buildListing(
   }
   const listing = {
     v: 1 as const,
-    claim,
     name: identity.name,
     domain: identity.website,
     category: form.category,
@@ -123,25 +117,3 @@ export function buildListing(
   };
   return parseTelemetryRanking(JSON.stringify(listing));
 }
-
-/** The `community/ranking/<domain>.json` file that approves this install. */
-export function rankingEntryFile(listing: Pick<TelemetryRanking, "domain" | "claim">): string {
-  return `${JSON.stringify({ $schema: "./schema.json", domain: listing.domain, claim: listing.claim }, null, 2)}\n`;
-}
-
-export const RANKING_REPO = "desplega-ai/agent-swarm";
-
-/** GitHub's "new file" page, prefilled with the entry, as a PR from the admin's fork. */
-export function rankingPrUrl(listing: Pick<TelemetryRanking, "domain" | "claim">): string {
-  const params = new URLSearchParams({
-    filename: `community/ranking/${listing.domain}.json`,
-    value: rankingEntryFile(listing),
-    message: `chore(ranking): add ${listing.domain}`,
-  });
-  return `https://github.com/${RANKING_REPO}/new/main?${params.toString()}`;
-}
-
-/** GitHub's delete page for an entry, to leave the ranking for good. */
-export function rankingLeaveUrl(domain: string): string {
-  return `https://github.com/${RANKING_REPO}/delete/main/community/ranking/${domain}.json`;
-}

package/src/scripts-runtime/sdk-allowlist.ts

@@ -180,6 +180,13 @@ export const SDK_TOOL_NAME_MAP = {
   app_list: "app-list",
   app_patch: "app-patch",
   app_query: "app-query",
+  app_rows_list: "app-rows-list",
+  app_row_get: "app-row-get",
+  app_row_create: "app-row-create",
+  app_rows_create: "app-rows-create",
+  app_row_patch: "app-row-patch",
+  app_row_delete: "app-row-delete",
+  app_rows_delete: "app-rows-delete",
   app_rollback: "app-rollback",
   app_sync: "app-sync",
   app_upsert: "app-upsert",

package/src/scripts-runtime/types/stdlib.d.ts

@@ -658,6 +658,37 @@ declare module "swarm-sdk" {
       query: string;
       params?: Record<string, string | number | boolean>;
     }): Promise<unknown>;
+    app_rows_list(args: {
+      appId: string;
+      model: string;
+      equals?: Record<string, string | number | boolean>;
+      sort?: `${string}:asc` | `${string}:desc`;
+      limit?: number;
+    }): Promise<unknown>;
+    app_row_get(args: { appId: string; model: string; rowId: string }): Promise<unknown>;
+    app_row_create(args: {
+      appId: string;
+      model: string;
+      values: Record<string, unknown>;
+    }): Promise<unknown>;
+    app_rows_create(args: {
+      appId: string;
+      model: string;
+      rows: Record<string, unknown>[];
+    }): Promise<unknown>;
+    app_row_patch(args: {
+      appId: string;
+      model: string;
+      rowId: string;
+      values: Record<string, unknown>;
+    }): Promise<unknown>;
+    app_row_delete(args: { appId: string; model: string; rowId: string }): Promise<unknown>;
+    app_rows_delete(args: {
+      appId: string;
+      model: string;
+      equals: Record<string, string | number | boolean>;
+      limit?: number;
+    }): Promise<unknown>;
     app_rollback(args: {
       appId: string;
       version: number;

package/src/scripts-runtime/types/swarm-sdk.d.ts

@@ -640,6 +640,37 @@ declare module "swarm-sdk" {
       query: string;
       params?: Record<string, string | number | boolean>;
     }): Promise<unknown>;
+    app_rows_list(args: {
+      appId: string;
+      model: string;
+      equals?: Record<string, string | number | boolean>;
+      sort?: `${string}:asc` | `${string}:desc`;
+      limit?: number;
+    }): Promise<unknown>;
+    app_row_get(args: { appId: string; model: string; rowId: string }): Promise<unknown>;
+    app_row_create(args: {
+      appId: string;
+      model: string;
+      values: Record<string, unknown>;
+    }): Promise<unknown>;
+    app_rows_create(args: {
+      appId: string;
+      model: string;
+      rows: Record<string, unknown>[];
+    }): Promise<unknown>;
+    app_row_patch(args: {
+      appId: string;
+      model: string;
+      rowId: string;
+      values: Record<string, unknown>;
+    }): Promise<unknown>;
+    app_row_delete(args: { appId: string; model: string; rowId: string }): Promise<unknown>;
+    app_rows_delete(args: {
+      appId: string;
+      model: string;
+      equals: Record<string, string | number | boolean>;
+      limit?: number;
+    }): Promise<unknown>;
     app_rollback(args: {
       appId: string;
       version: number;

package/src/server.ts

@@ -11,6 +11,7 @@ import { resolveTemplate } from "./prompts/resolver";
 import { isRbacEnabled } from "./rbac";
 import { getSlackConfiguration } from "./slack/config";
 import { registerAcceptSteerTool } from "./tools/accept-steer";
+import { registerAppActionRunTool } from "./tools/app-action-run";
 import { registerAppDiffTool } from "./tools/app-diff";
 import { registerAppGetTool } from "./tools/app-get";
 import { registerAppHistoryTool } from "./tools/app-history";
@@ -18,6 +19,7 @@ import { registerAppListTool } from "./tools/app-list";
 import { registerAppPatchTool } from "./tools/app-patch";
 import { registerAppQueryTool } from "./tools/app-query";
 import { registerAppRollbackTool } from "./tools/app-rollback";
+import { registerAppRowTools } from "./tools/app-rows";
 import { registerAppSyncTool } from "./tools/app-sync";
 import { registerAppUpsertTool } from "./tools/app-upsert";
 import { registerCancelApprovalRequestTool } from "./tools/cancel-approval-request";
@@ -643,6 +645,8 @@ export async function createServer(
   // Pages capability - DB-backed lightweight artifacts (HTML / JSON specs).
   if (hasCapability("pages")) {
     registerAppGetTool(server);
+    registerAppRowTools(server);
+    registerAppActionRunTool(server);
     registerAppHistoryTool(server);
     registerAppDiffTool(server);
     registerAppListTool(server);