@siglume/api-sdk 0.10.7 → 0.10.8

package/README.md

@@ -1,91 +1,99 @@
-# @siglume/api-sdk
-
-TypeScript runtime for building, testing, and registering Siglume developer apps.
-
-This package is prepared in the public SDK repo and ships with the current v0.10.x release line.
-
-It also includes `draft_tool_manual()` and `fill_tool_manual_gaps()` with
-bundled `AnthropicProvider` and `OpenAIProvider` classes. Provide
-`ANTHROPIC_API_KEY` or `OPENAI_API_KEY`, then:
-
-```ts
-import { AnthropicProvider, draft_tool_manual } from "@siglume/api-sdk";
-
-const result = await draft_tool_manual({
-  capability_key: "currency-converter-jp",
-  job_to_be_done: "Convert USD amounts to JPY with live rates",
-  permission_class: "read_only",
-  llm: new AnthropicProvider(),
-});
-
-console.log(result.quality_report.grade);
-```
-
-Buyer-side discovery and export helpers are also included:
-
-```ts
-import { SiglumeBuyerClient, to_anthropic_tool } from "@siglume/api-sdk";
-
-const buyer = new SiglumeBuyerClient({
-  api_key: process.env.SIGLUME_API_KEY ?? "sig_mock_key",
-  default_agent_id: process.env.SIGLUME_AGENT_ID,
-});
-
-const listing = await buyer.get_listing("currency-converter-v2");
-const anthropicTool = to_anthropic_tool(listing.tool_manual).schema;
-```
-
-`SiglumeBuyerClient.invoke()` remains experimental and stays gated behind
-`allow_internal_execute: true` for privileged test environments until a public
-buyer execution route is available.
-
-See [`../docs/buyer-sdk.md`](../docs/buyer-sdk.md) and
-[`../examples/buyer_claude_agent_sdk.ts`](../examples/buyer_claude_agent_sdk.ts)
-for the current experimental limitations and the mocked integration example.
-
-You can also generate deterministic first-party owner-operation wrappers from
-the CLI without using an LLM:
-
-```bash
-siglume init --list-operations
-siglume init --from-operation owner.charter.update ./my-charter-editor
-```
-
-See [`../docs/template-generator.md`](../docs/template-generator.md) for the
-generated file layout, fallback behavior, and review samples.
-
-For API Store publishing, the recommended CLI flow is:
-
-```bash
-siglume init --template price-compare
-siglume test .
-siglume score . --offline
-
-# Issue SIGLUME_API_KEY from Developer Portal -> CLI / API keys before production checks:
-siglume validate .
-siglume score . --remote
-siglume preflight .         # checks blockers without creating a draft
-siglume register .          # preflight + auto-register + confirm/publish
-siglume register . --draft-only # review-only draft staging
-```
-
-`siglume register` reads `tool_manual.json`, the local Git-ignored
-`runtime_validation.json`, and optional local Git-ignored
-`oauth_credentials.json`. Generated projects keep runtime validation and OAuth
-credential files Git-ignored because they can contain review keys and client
-secrets. SDK / HTTP automation can pass
-`source_url`, `source_context`, and `input_form_spec` directly to
-`auto-register`. The CLI runs preflight by default, then calls the same
-`auto-register` route used by SDK / automation clients and confirms publication
-unless `--draft-only` is set. Re-run the same `capability_key` to publish a
-non-material upgrade when checks pass. The server-side publish gate
-includes runtime checks, contract checks, seller OAuth checks, pricing / payout
-rules, and a mandatory fail-closed LLM legal review for law compliance plus
-public-order / morals compliance.
-
-Game APIs use the same publishing flow. To make a listing eligible for the
-dedicated Game API Store entry point, include explicit game-oriented
-`compatibility_tags` in the manifest, for example `["game", "unity",
-"realtime", "npc"]`. Use concrete tags such as `game`, `unity`, `unreal`,
-`godot`, `npc`, `matchmaking`, `multiplayer`, `realtime`, `ugc`, or
-`narrative`; do not send arbitrary registration `metadata` for store placement.
+# @siglume/api-sdk
+
+TypeScript runtime for building, testing, and registering Siglume developer apps.
+
+This package is prepared in the public SDK repo and ships with the current v0.10.x release line.
+
+It also includes `draft_tool_manual()` and `fill_tool_manual_gaps()` with
+bundled `AnthropicProvider` and `OpenAIProvider` classes. Provide
+`ANTHROPIC_API_KEY` or `OPENAI_API_KEY`, then:
+
+```ts
+import { AnthropicProvider, draft_tool_manual } from "@siglume/api-sdk";
+
+const result = await draft_tool_manual({
+  capability_key: "currency-converter-jp",
+  job_to_be_done: "Convert USD amounts to JPY with live rates",
+  permission_class: "read_only",
+  llm: new AnthropicProvider(),
+});
+
+console.log(result.quality_report.grade);
+```
+
+Buyer-side discovery and export helpers are also included:
+
+```ts
+import { SiglumeBuyerClient, to_anthropic_tool } from "@siglume/api-sdk";
+
+const buyer = new SiglumeBuyerClient({
+  api_key: process.env.SIGLUME_API_KEY ?? "sig_mock_key",
+  default_agent_id: process.env.SIGLUME_AGENT_ID,
+});
+
+const listing = await buyer.get_listing("currency-converter-v2");
+const anthropicTool = to_anthropic_tool(listing.tool_manual).schema;
+```
+
+`SiglumeBuyerClient.invoke()` remains experimental and stays gated behind
+`allow_internal_execute: true` for privileged test environments until a public
+buyer execution route is available.
+
+See [`../docs/buyer-sdk.md`](../docs/buyer-sdk.md) and
+[`../examples/buyer_claude_agent_sdk.ts`](../examples/buyer_claude_agent_sdk.ts)
+for the current experimental limitations and the mocked integration example.
+
+You can also generate deterministic first-party owner-operation wrappers from
+the CLI without using an LLM:
+
+```bash
+siglume init --list-operations
+siglume init --from-operation owner.charter.update ./my-charter-editor
+```
+
+See [`../docs/template-generator.md`](../docs/template-generator.md) for the
+generated file layout, fallback behavior, and review samples.
+
+For API Store publishing, the recommended CLI flow is:
+
+```bash
+siglume init --template price-compare
+siglume test .
+siglume score . --offline
+
+# Issue SIGLUME_API_KEY from Developer Portal -> CLI / API keys before production checks:
+siglume validate .
+siglume score . --remote
+siglume preflight .         # checks blockers without creating a draft
+siglume register .          # preflight + auto-register + confirm/publish
+siglume register . --draft-only # review-only draft staging
+siglume companies           # list company publishers available to this key
+siglume register . --company company_123
+```
+
+`siglume register` reads `tool_manual.json`, the local Git-ignored
+`runtime_validation.json`, and optional local Git-ignored
+`oauth_credentials.json`. Generated projects keep runtime validation and OAuth
+credential files Git-ignored because they can contain review keys and client
+secrets. SDK / HTTP automation can pass
+`source_url`, `source_context`, and `input_form_spec` directly to
+`auto-register`. The CLI runs preflight by default, then calls the same
+`auto-register` route used by SDK / automation clients and confirms publication
+unless `--draft-only` is set. Re-run the same `capability_key` to publish a
+non-material upgrade when checks pass. The server-side publish gate
+includes runtime checks, contract checks, seller OAuth checks, pricing / payout
+rules, and a mandatory fail-closed LLM legal review for law compliance plus
+public-order / morals compliance.
+
+Company-name publishing is founder-only in the Phase 2 MVP. Use
+`publisher_type: "company"` with `company_id` in `app_manifest.yaml`, or pass
+`--company <company_id>` to the CLI. Paid company listings require the
+company's verified settlement wallet; Siglume does not fall back to the
+registrant's personal payout wallet.
+
+Game APIs use the same publishing flow. To make a listing eligible for the
+dedicated Game API Store entry point, include explicit game-oriented
+`compatibility_tags` in the manifest, for example `["game", "unity",
+"realtime", "npc"]`. Use concrete tags such as `game`, `unity`, `unreal`,
+`godot`, `npc`, `matchmaking`, `multiplayer`, `realtime`, `ugc`, or
+`narrative`; do not send arbitrary registration `metadata` for store placement.

package/dist/bin/siglume.cjs

@@ -1247,6 +1247,56 @@ var init_operations = __esm({
 });
 
 // src/client.ts
+function validateManifestPersistenceContract(payload) {
+  const vertical = String(payload.store_vertical ?? "").trim().toLowerCase();
+  const persistence = payload.persistence;
+  if (persistence === void 0 || persistence === null) {
+    return;
+  }
+  if (!isRecord(persistence)) {
+    throw new SiglumeClientError("AppManifest.persistence must be an object.");
+  }
+  const mode = String(persistence.mode ?? (vertical === "game" ? "platform" : "none")).trim().toLowerCase();
+  if (!["none", "local", "platform", "developer_server"].includes(mode)) {
+    throw new SiglumeClientError(
+      "AppManifest.persistence.mode must be one of: none, local, platform, developer_server."
+    );
+  }
+  const schema = persistence.save_data_schema;
+  if (vertical === "game" && mode !== "none" && schema === void 0) {
+    throw new SiglumeClientError(
+      "AppManifest.persistence.save_data_schema is required when store_vertical='game' and persistence.mode is not 'none'."
+    );
+  }
+  if (schema !== void 0) {
+    validateSaveDataSchema(schema, "AppManifest.persistence.save_data_schema");
+  }
+}
+function validateSaveDataSchema(schema, fieldName) {
+  if (!isRecord(schema)) {
+    throw new SiglumeClientError(`${fieldName} must be a JSON Schema object.`);
+  }
+  const schemaSize = new TextEncoder().encode(JSON.stringify(schema)).length;
+  if (schemaSize > 8192) {
+    throw new SiglumeClientError(`${fieldName} must be at most 8192 bytes.`);
+  }
+  if (schema.type !== "object") {
+    throw new SiglumeClientError(`${fieldName}.type must be 'object'.`);
+  }
+  const properties = schema.properties;
+  if (!isRecord(properties) || Object.keys(properties).length === 0) {
+    throw new SiglumeClientError(`${fieldName}.properties must be a non-empty object.`);
+  }
+  if (schema.required !== void 0) {
+    if (!Array.isArray(schema.required) || !schema.required.every((item) => typeof item === "string")) {
+      throw new SiglumeClientError(`${fieldName}.required must be an array of strings when provided.`);
+    }
+    const missing = schema.required.filter((item) => !(item in properties));
+    if (missing.length > 0) {
+      throw new SiglumeClientError(`${fieldName}.required references undefined properties: ${missing.join(", ")}.`);
+    }
+  }
+}
 function buildToolManualQualityReport(payload) {
   const qualityBlock = isRecord(payload.quality) ? payload.quality : payload;
   const issues = [];
@@ -1321,6 +1371,8 @@ function buildUrl(baseUrl, path, params) {
   return url.toString();
 }
 function parseListing(data) {
+  const metadata = isRecord(data.metadata) ? data.metadata : {};
+  const persistence = isRecord(data.persistence) ? data.persistence : isRecord(metadata.persistence) ? metadata.persistence : {};
   return {
     listing_id: String(data.listing_id ?? data.id ?? ""),
     capability_key: String(data.capability_key ?? ""),
@@ -1343,14 +1395,59 @@ function parseListing(data) {
     seller_display_name: stringOrNull(data.seller_display_name),
     seller_homepage_url: stringOrNull(data.seller_homepage_url),
     seller_social_url: stringOrNull(data.seller_social_url),
+    publisher_type: stringOrNull(data.publisher_type),
+    publisher_company_id: stringOrNull(data.publisher_company_id),
+    company_id: stringOrNull(data.company_id),
+    company_name: stringOrNull(data.company_name),
+    company_publish_status: stringOrNull(data.company_publish_status),
+    company_terms_version: stringOrNull(data.company_terms_version),
     review_status: stringOrNull(data.review_status),
     review_note: stringOrNull(data.review_note),
     submission_blockers: Array.isArray(data.submission_blockers) ? data.submission_blockers.filter((item) => typeof item === "string") : [],
+    persistence: { ...persistence },
     created_at: stringOrNull(data.created_at),
     updated_at: stringOrNull(data.updated_at),
     raw: { ...data }
   };
 }
+function parseCompanyPublisher(data) {
+  const wallets = Array.isArray(data.settlement_wallets) ? data.settlement_wallets.filter((item) => isRecord(item)) : [];
+  return {
+    company_id: String(data.company_id ?? data.id ?? ""),
+    name: String(data.name ?? ""),
+    status: String(data.status ?? ""),
+    description: stringOrNull(data.description),
+    is_founder: Boolean(data.is_founder ?? false),
+    membership_role: stringOrNull(data.membership_role),
+    membership_status: stringOrNull(data.membership_status),
+    can_publish: Boolean(data.can_publish ?? true),
+    can_approve: Boolean(data.can_approve ?? false),
+    approval_required: Boolean(data.approval_required ?? false),
+    paid_listing_allowed: Boolean(data.paid_listing_allowed ?? false),
+    disabled_reasons: Array.isArray(data.disabled_reasons) ? data.disabled_reasons.filter((item) => typeof item === "string") : [],
+    company_terms_version: stringOrNull(data.company_terms_version),
+    active_listing_count: Number(data.active_listing_count ?? 0),
+    pending_approval_count: Number(data.pending_approval_count ?? 0),
+    settlement_wallet_ready: Boolean(data.settlement_wallet_ready ?? false),
+    settlement_wallets: wallets.map((item) => ({ ...item })),
+    raw: { ...data }
+  };
+}
+function parseCapabilitySaveState(data) {
+  return {
+    capability_key: String(data.capability_key ?? ""),
+    save_key: String(data.save_key ?? ""),
+    schema_version: String(data.schema_version ?? "1"),
+    revision: Number(data.revision ?? 0),
+    payload: toRecord(data.payload),
+    metadata: toRecord(data.metadata),
+    checksum: stringOrNull(data.checksum),
+    updated_at: stringOrNull(data.updated_at),
+    created_at: stringOrNull(data.created_at),
+    exists: Boolean(data.exists ?? false),
+    raw: { ...data }
+  };
+}
 function parseBundleMember(data) {
   return {
     capability_listing_id: String(data.capability_listing_id ?? ""),
@@ -2530,6 +2627,9 @@ var init_client = __esm({
           "support_contact",
           "seller_homepage_url",
           "seller_social_url",
+          "publisher_type",
+          "company_id",
+          "publisher_company_id",
           "store_vertical",
           "jurisdiction",
           "price_model",
@@ -2542,7 +2642,8 @@ var init_client = __esm({
           "dry_run_supported",
           "required_connected_accounts",
           "permission_scopes",
-          "compatibility_tags"
+          "compatibility_tags",
+          "persistence"
         ]) {
           const value = manifestPayload[fieldName];
           if (value !== void 0 && value !== null) {
@@ -2582,6 +2683,26 @@ var init_client = __esm({
             );
           }
         }
+        const explicitPublisherType = payload.publisher_type !== void 0 && payload.publisher_type !== null;
+        const companyId = String(payload.company_id ?? "").trim() || String(payload.publisher_company_id ?? "").trim();
+        const publisherType = String(payload.publisher_type ?? "user").trim().toLowerCase();
+        if (publisherType !== "user" && publisherType !== "company") {
+          throw new SiglumeClientError("AppManifest.publisher_type must be 'user' or 'company'.");
+        }
+        if (publisherType === "company" && !companyId) {
+          throw new SiglumeClientError("AppManifest.company_id is required when publisher_type='company'.");
+        }
+        if (publisherType === "user" && companyId) {
+          throw new SiglumeClientError("AppManifest.company_id cannot be combined with publisher_type='user'.");
+        }
+        if (explicitPublisherType || companyId) {
+          payload.publisher_type = publisherType;
+        }
+        if (companyId) {
+          payload.company_id = companyId;
+          payload.publisher_company_id = companyId;
+        }
+        validateManifestPersistenceContract(payload);
         if (payload.manifest && typeof payload.manifest === "object") {
           delete payload.manifest.version;
         }
@@ -2689,6 +2810,45 @@ var init_client = __esm({
         const [data] = await this.request("GET", `/market/capabilities/${listing_id}`);
         return parseListing(data);
       }
+      async list_company_publishers() {
+        const [data] = await this.request("GET", "/market/company-publishers");
+        return Array.isArray(data.items) ? data.items.filter((item) => isRecord(item)).map(parseCompanyPublisher) : [];
+      }
+      async request_company_publish_approval(listing_id, note) {
+        const [data] = await this.request("POST", `/market/capabilities/${listing_id}/company-publish-approval`, {
+          json_body: note ? { note } : {}
+        });
+        return parseListing(data);
+      }
+      async decide_company_publish_approval(listing_id, options) {
+        const [data] = await this.request("POST", `/market/capabilities/${listing_id}/company-publish-approval/decision`, {
+          json_body: {
+            decision: options.decision,
+            ...options.reason ? { reason: options.reason } : {}
+          }
+        });
+        return parseListing(data);
+      }
+      async get_capability_state(capability_key, save_key = "default") {
+        const [data] = await this.request("GET", `/market/capability-state/${capability_key}/${save_key}`);
+        return parseCapabilitySaveState(data);
+      }
+      async put_capability_state(capability_key, save_key = "default", payload = {}, options = {}) {
+        const body = {
+          payload: toRecord(payload),
+          schema_version: options.schema_version ?? "1",
+          metadata: toRecord(options.metadata)
+        };
+        if (options.expected_revision !== void 0 && options.expected_revision !== null) {
+          body.expected_revision = Math.trunc(options.expected_revision);
+        }
+        const [data] = await this.request("PUT", `/market/capability-state/${capability_key}/${save_key}`, { json_body: body });
+        return parseCapabilitySaveState(data);
+      }
+      async delete_capability_state(capability_key, save_key = "default") {
+        const [data] = await this.request("DELETE", `/market/capability-state/${capability_key}/${save_key}`);
+        return parseCapabilitySaveState(data);
+      }
       // ----- Capability bundles (v0.7 track 2) ---------------------------------
       async list_bundles(options = {}) {
         const params = {
@@ -7283,7 +7443,12 @@ function ensureManifestPublisherIdentity(project) {
   const sellerHomepageUrl = String(manifestPayload.seller_homepage_url ?? "").trim();
   const sellerSocialUrl = String(manifestPayload.seller_social_url ?? "").trim();
   const jurisdiction = String(manifestPayload.jurisdiction ?? "").trim();
+  const companyId = String(manifestPayload.company_id ?? "").trim() || String(manifestPayload.publisher_company_id ?? "").trim();
+  const publisherType = String(manifestPayload.publisher_type ?? "user").trim().toLowerCase();
   const issues = [];
+  if (companyId && publisherType !== "company") {
+    issues.push('manifest.company_id requires manifest.publisher_type to be "company"');
+  }
   if (!docsUrl) {
     issues.push("manifest.docs_url is required");
   } else if (looksLikePlaceholder(docsUrl)) {
@@ -7429,25 +7594,110 @@ ${errors.map((error) => `- ${error}`).join("\n")}`
   }
   return preflight;
 }
+function companyNameSlug(value) {
+  return value.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
 async function runRegistration(path = ".", options = {}, deps = {}) {
   const project = await loadProject(path);
+  let requestedCompanyId = String(options.company_id ?? "").trim();
+  const requestedCompanySlug = String(options.company_slug ?? "").trim();
+  let companyPublisherCandidates = null;
+  if (requestedCompanySlug) {
+    if (requestedCompanyId) {
+      throw new SiglumeProjectError("--company and --company-slug cannot be combined.");
+    }
+    const slug = companyNameSlug(requestedCompanySlug);
+    if (!slug && requestedCompanySlug !== requestedCompanyId) {
+      throw new SiglumeProjectError(`Company slug ${requestedCompanySlug} is not slug-compatible; use --company <company_id> instead.`);
+    }
+  }
+  if (requestedCompanyId) {
+    project.manifest = {
+      ...project.manifest,
+      publisher_type: "company",
+      company_id: requestedCompanyId,
+      publisher_company_id: requestedCompanyId
+    };
+  }
   ensureExplicitToolManual(project);
   ensureManifestPublisherIdentity(project);
   ensureRuntimeValidationReady(project);
   ensureRequiredOauthCredentials(project);
   const canonicalOauthCredentials = canonicalOauthCredentialsPayload(project.oauth_credentials);
   const client = await createClient(deps);
+  if (requestedCompanySlug) {
+    const slug = companyNameSlug(requestedCompanySlug);
+    companyPublisherCandidates = await client.list_company_publishers();
+    const matches = companyPublisherCandidates.filter(
+      (item) => companyNameSlug(item.name || item.company_id) === slug || item.company_id === requestedCompanySlug
+    );
+    if (matches.length === 0) {
+      throw new SiglumeProjectError(`Company slug ${requestedCompanySlug} is not available to this API key.`);
+    }
+    if (matches.length > 1) {
+      throw new SiglumeProjectError(`Company slug ${requestedCompanySlug} is ambiguous; use --company <company_id> instead.`);
+    }
+    const match = matches[0];
+    if (!match) {
+      throw new SiglumeProjectError(`Company slug ${requestedCompanySlug} is not available to this API key.`);
+    }
+    if (match.can_publish === false) {
+      const disabledReasons = match.disabled_reasons ?? [];
+      const reasons = disabledReasons.length > 0 ? disabledReasons.join(", ") : "company publisher is disabled";
+      throw new SiglumeProjectError(`Company ${match.company_id} cannot publish: ${reasons}.`);
+    }
+    requestedCompanyId = match.company_id;
+    project.manifest = {
+      ...project.manifest,
+      publisher_type: "company",
+      company_id: requestedCompanyId,
+      publisher_company_id: requestedCompanyId
+    };
+  }
   const preflight = await registrationPreflight(project, client);
+  let companyPublisherPreflight = null;
+  const companyId = String(project.manifest.company_id ?? "").trim() || String(project.manifest.publisher_company_id ?? "").trim();
+  const publisherType = String(project.manifest.publisher_type ?? "user").toLowerCase();
+  if (publisherType === "company") {
+    if (!companyId) {
+      throw new SiglumeProjectError("Company registration requires --company <company_id> or manifest.company_id.");
+    }
+    const companies = companyPublisherCandidates ?? await client.list_company_publishers();
+    companyPublisherCandidates = companies;
+    const company = companies.find((item) => item.company_id === companyId);
+    if (!company) {
+      throw new SiglumeProjectError(`Company ${companyId} is not available to this API key.`);
+    }
+    if (company.can_publish === false) {
+      const disabledReasons = company.disabled_reasons ?? [];
+      const reasons = disabledReasons.length > 0 ? disabledReasons.join(", ") : "company publisher is disabled";
+      throw new SiglumeProjectError(`Company ${companyId} cannot publish: ${reasons}.`);
+    }
+    companyPublisherPreflight = company;
+  }
   let developerPortalPreflight = null;
   if (String(project.manifest.price_model ?? "free").toLowerCase() !== "free") {
-    const portal = await client.get_developer_portal();
-    const verifiedDestination = portal.payout_readiness?.verified_destination;
-    if (verifiedDestination !== true) {
-      throw new SiglumeProjectError(
-        "Paid API registration requires a verified Polygon payout destination. Open https://siglume.com/owner/credits/payout and confirm the embedded-wallet payout token, or call GET /v1/market/developer/portal until payout_readiness.verified_destination is true."
-      );
+    if (publisherType === "company") {
+      const company = companyPublisherPreflight;
+      if (!company) {
+        throw new SiglumeProjectError(`Company ${companyId} is not available to this API key.`);
+      }
+      if (company.settlement_wallet_ready !== true) {
+        throw new SiglumeProjectError(
+          `Paid company registration requires a verified company settlement wallet for ${company.name}. Open the company settings and complete settlement readiness before registering.`
+        );
+      }
+      developerPortalPreflight = { company_publisher: toJsonable(company) };
+    } else {
+      const portal = await client.get_developer_portal();
+      const verifiedDestination = portal.payout_readiness?.verified_destination;
+      if (verifiedDestination !== true) {
+        throw new SiglumeProjectError(
+          "Paid API registration requires a verified Polygon payout destination. Open https://siglume.com/owner/credits/payout and confirm the embedded-wallet payout token, or call GET /v1/market/developer/portal until payout_readiness.verified_destination is true."
+        );
+      }
+      developerPortalPreflight = toJsonable(portal);
     }
-    developerPortalPreflight = toJsonable(portal);
   }
   const receipt = await client.auto_register(project.manifest, project.tool_manual, {
     runtime_validation: project.runtime_validation,
@@ -7520,6 +7770,14 @@ async function getUsageReport(options, deps = {}) {
     count: items.length
   };
 }
+async function listCompanyPublishersReport(deps = {}) {
+  const client = await createClient(deps);
+  const companies = await client.list_company_publishers();
+  return {
+    companies: companies.map((item) => toJsonable(item)),
+    count: companies.length
+  };
+}
 async function diffJsonFiles(oldPath, newPath) {
   const oldPayload = await loadJsonDocument(oldPath);
   const newPayload = await loadJsonDocument(newPath);
@@ -8606,6 +8864,24 @@ function renderOperationTable(operations) {
     ...rows.map((row) => row.map((cell, index) => cell.padEnd(widths[index] ?? cell.length)).join("  "))
   ];
 }
+function renderCompanyTable(companies) {
+  const rows = companies.map((item) => [
+    String(item.company_id ?? item.id ?? ""),
+    String(item.name ?? ""),
+    String(item.membership_role ?? (item.is_founder ? "founder" : "")),
+    String(item.settlement_wallet_ready === true ? "ready" : "not_ready"),
+    String(item.pending_approval_count ?? 0)
+  ]);
+  const headers = ["company_id", "name", "role", "settlement", "pending"];
+  const widths = headers.map(
+    (header, index) => Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0))
+  );
+  return [
+    headers.map((header, index) => header.padEnd(widths[index] ?? header.length)).join("  "),
+    widths.map((width) => "-".repeat(width)).join("  "),
+    ...rows.map((row) => row.map((cell, index) => cell.padEnd(widths[index] ?? cell.length)).join("  "))
+  ];
+}
 async function runCli(argv, deps = {}) {
   const stdout = deps.stdout;
   const stderr = deps.stderr ?? console.error;
@@ -8762,7 +9038,21 @@ async function runCli(argv, deps = {}) {
     if (report.runtime_validation_path) emit(stdout, `runtime_validation_path: ${String(report.runtime_validation_path)}`);
     if (report.oauth_credentials_path) emit(stdout, `oauth_credentials_path: ${String(report.oauth_credentials_path)}`);
   });
-  program.command("register").option("--confirm", "explicitly confirm the registration; this is the default unless --draft-only is set", false).option("--draft-only", "create or refresh the draft without confirming publication", false).option("--submit-review", "legacy alias: publish immediately if your environment still routes through submit-review", false).option("--json", "emit machine-readable JSON", false).argument("[path]", ".", "project path").action(async (path, options) => {
+  program.command("companies").description("List Siglume companies available for company-name publishing.").option("--json", "emit machine-readable JSON", false).action(async (options) => {
+    const report = await listCompanyPublishersReport(deps);
+    if (options.json) {
+      emit(stdout, renderJson(report));
+      return;
+    }
+    const companies = Array.isArray(report.companies) ? report.companies.filter((item) => Boolean(item && typeof item === "object")) : [];
+    if (companies.length === 0) {
+      emit(stdout, "No company publishers available for this API key.");
+      return;
+    }
+    emit(stdout, "Company publishers");
+    renderCompanyTable(companies).forEach((line) => emit(stdout, line));
+  });
+  program.command("register").option("--confirm", "explicitly confirm the registration; this is the default unless --draft-only is set", false).option("--draft-only", "create or refresh the draft without confirming publication", false).option("--submit-review", "legacy alias: publish immediately if your environment still routes through submit-review", false).option("--company <companyId>", "publish under a Siglume company name; revenue is split equally among active members", "").option("--company-slug <slug>", "publish under a Siglume company by matching the slugified company name", "").option("--json", "emit machine-readable JSON", false).argument("[path]", ".", "project path").action(async (path, options) => {
     const draftOnly = Boolean(options.draftOnly);
     if (draftOnly && options.confirm) {
       throw new SiglumeProjectError("--draft-only cannot be combined with --confirm.");
@@ -8771,7 +9061,13 @@ async function runCli(argv, deps = {}) {
       throw new SiglumeProjectError("--draft-only cannot be combined with --submit-review.");
     }
     const shouldConfirm = Boolean(options.confirm) || !draftOnly && !options.submitReview;
-    const report = await runRegistration(path, { confirm: shouldConfirm, draft_only: draftOnly, submit_review: options.submitReview }, deps);
+    const report = await runRegistration(path, {
+      confirm: shouldConfirm,
+      draft_only: draftOnly,
+      submit_review: options.submitReview,
+      company_id: options.company,
+      company_slug: options.companySlug
+    }, deps);
     if (options.json) {
       emit(stdout, renderJson(report));
     } else {