@signaliz/cli 1.0.18 → 1.0.19

package/dist/bin.js

@@ -100,7 +100,7 @@ function normalizeCampaignBuildInput(raw) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
   };
   const policy = nested("policy", "policy");
-  const signals = nested("signals", "signals");
+  const signals2 = nested("signals", "signals");
   const copy = nested("copy", "copy");
   const delivery = nested("delivery", "delivery");
   const learningHoldout = nested("learning_holdout", "learningHoldout");
@@ -131,11 +131,11 @@ function normalizeCampaignBuildInput(raw) {
       maxCredits: policy.max_credits ?? policy.maxCredits,
       verifyEmails: policy.verify_emails ?? policy.verifyEmails
     } : void 0,
-    signals: signals ? {
-      ...signals,
-      customPrompt: signals.custom_prompt ?? signals.customPrompt,
-      confidenceThreshold: signals.confidence_threshold ?? signals.confidenceThreshold,
-      lookbackDays: signals.lookback_days ?? signals.lookbackDays
+    signals: signals2 ? {
+      ...signals2,
+      customPrompt: signals2.custom_prompt ?? signals2.customPrompt,
+      confidenceThreshold: signals2.confidence_threshold ?? signals2.confidenceThreshold,
+      lookbackDays: signals2.lookback_days ?? signals2.lookbackDays
     } : void 0,
     qualification: nested("qualification", "qualification"),
     copy: copy ? {
@@ -431,6 +431,69 @@ function parseJsonObjectFromString(value, label) {
   }
   return parsed;
 }
+var PUBLIC_GROUND_TRUTH_CLI_FILTERS = [
+  ["industry", "industry"],
+  ["location", "location"],
+  ["nativeId", "native-id", "nativeId"],
+  ["entityName", "entity-name", "entityName"],
+  ["domain", "domain"],
+  ["websiteUrl", "website-url", "websiteUrl"],
+  ["phone", "phone"],
+  ["email", "email"],
+  ["city", "city"],
+  ["state", "state"],
+  ["postalCode", "postal-code", "postalCode"],
+  ["country", "country"],
+  ["sourceUrl", "source-url", "sourceUrl"],
+  ["naics", "naics"],
+  ["industryCode", "industry-code", "industryCode"],
+  ["industryType", "industry-type", "industryType"],
+  ["year", "year"],
+  ["quarter", "quarter"],
+  ["areaFips", "area-fips", "areaFips"],
+  ["geoId", "geo-id", "geoId"],
+  ["ownCode", "own-code", "ownCode"],
+  ["sourceUpdatedAfter", "source-updated-after", "sourceUpdatedAfter"],
+  ["sourceUpdatedBefore", "source-updated-before", "sourceUpdatedBefore"],
+  ["observedAfter", "observed-after", "observedAfter"],
+  ["observedBefore", "observed-before", "observedBefore"]
+];
+function commandObjectFromKeyValueFlags(flags, keyValueNames, jsonNames) {
+  const object = {};
+  for (const jsonName of jsonNames) {
+    const parsed = commandJsonObjectFlag(flags, jsonName);
+    if (parsed) Object.assign(object, parsed);
+  }
+  for (const pair of repeatedCommandStringFlag(flags, ...keyValueNames)) {
+    const eq = pair.indexOf("=");
+    if (eq <= 0) die(`Expected key=value for --${keyValueNames[0]}`);
+    const key = pair.slice(0, eq).trim();
+    const value = pair.slice(eq + 1).trim();
+    if (!key) die(`Expected non-empty key for --${keyValueNames[0]}`);
+    object[key] = value;
+  }
+  return Object.keys(object).length > 0 ? object : void 0;
+}
+function publicGroundTruthFiltersFromCommandFlags(flags) {
+  const filters = {};
+  for (const [paramName, ...flagNames] of PUBLIC_GROUND_TRUTH_CLI_FILTERS) {
+    const value = commandStringFlag(flags, ...flagNames);
+    if (value) filters[paramName] = value;
+  }
+  const joinKeys = commandObjectFromKeyValueFlags(
+    flags,
+    ["join-key", "joinKey"],
+    ["join-keys-json", "joinKeysJson"]
+  );
+  const rowData = commandObjectFromKeyValueFlags(
+    flags,
+    ["row-data", "rowData"],
+    ["row-data-json", "rowDataJson"]
+  );
+  if (joinKeys) filters.joinKeys = joinKeys;
+  if (rowData) filters.rowData = rowData;
+  return filters;
+}
 function output(data, humanFn) {
   if (jsonMode()) {
     console.log(JSON.stringify(data, null, 2));
@@ -608,6 +671,7 @@ function inferMcpToolCategory(toolName) {
   }
   if (toolName.includes("icp")) return "icp";
   if (toolName.startsWith("ai_clean_")) return "data_cleaning";
+  if (toolName.includes("public_ground_truth")) return "public_data";
   if (toolName.includes("system") || toolName.includes("workflow")) return "automation";
   if (toolName.includes("agent") || toolName.includes("platform_health") || toolName === "discover_capabilities") return "observability";
   return void 0;
@@ -1097,6 +1161,10 @@ Discovery:
     --category NAME       Filter by category
   discover --query "..."  Find relevant MCP tools/capabilities
     --category NAME       Optional category filter, e.g. ops or enrichment
+  public-data search      Search public registry/cache records
+    --query "..."         Company/name/domain/native ID search text
+    --source-id ID        Optional source filter
+  public-data sources     List public data source IDs and join-key metadata
 
 AI:
 	  ai multi-model          Run Custom AI Enrichment - Multi Model
@@ -1113,6 +1181,22 @@ AI:
 	                          Record fields containing attachment URLs/arrays
 	    --max-concurrency N   Record concurrency, default 3, maximum 5
 	    --confirm-spend       Required to run spendful AI enrichment
+	  ai fusion               Run AI Enrichment Fusion with OpenRouter Fusion
+	    --prompt "..."        Prompt/template for each record (required)
+	    --preset general-budget|general-high
+	    --records-file FILE   JSON array, or object with records/inputs/data
+	    --output-fields a:text,b:number
+	    --dry-run             Default. Return a no-spend Fusion plan
+	    --confirm-spend       Run a live experimental probe with dry_run=false
+
+Signals:
+	  signals enrich          Run canonical web-grounded company signal enrichment (up to 15 signals)
+	  signals fusion          Run Signal Fusion for company signal intelligence
+	    --domain example.com  Company domain, or use --company-name
+	    --preset general-budget|general-high
+	    --signal-types hiring,funding
+	    --dry-run             Default. Return a no-spend Fusion plan
+	    --confirm-spend       Run a live experimental probe with dry_run=false
 
 Lead Generation:
   lead generate           Start a B2B lead-generation job
@@ -2717,6 +2801,111 @@ async function discover(rest) {
     }
   );
 }
+function publicDataPositionalText(rest) {
+  const parts = [];
+  for (let i = 0; i < rest.length; i += 1) {
+    const part = rest[i];
+    if (part.startsWith("--")) {
+      if (!part.includes("=") && rest[i + 1] && !rest[i + 1].startsWith("--")) i += 1;
+      continue;
+    }
+    parts.push(part);
+  }
+  return parts.join(" ").trim() || void 0;
+}
+function publicDataCell(value, width) {
+  const text = String(value ?? "").replace(/\s+/g, " ").trim();
+  return text.length > width ? `${text.slice(0, Math.max(width - 3, 0))}...` : text;
+}
+function printPublicDataSearchResult(result) {
+  const records = Array.isArray(result.records) ? result.records : [];
+  console.log(`Public data search: ${result.total_count ?? 0} matches (${records.length} returned)`);
+  if (result.query) console.log(`Query: ${result.query}`);
+  if (result.source_id) console.log(`Source: ${result.source_id}`);
+  if (result.entity_type) console.log(`Entity type: ${result.entity_type}`);
+  if (!records.length) {
+    console.log("No records matched.");
+    return;
+  }
+  console.log("");
+  console.log("Source".padEnd(22) + "Native ID".padEnd(22) + "Name".padEnd(42) + "Industry".padEnd(28) + "Domain".padEnd(24) + "Loc".padEnd(12) + "Match");
+  console.log("-".repeat(160));
+  for (const record2 of records) {
+    const loc = [record2.city, record2.state].filter(Boolean).join(", ");
+    const industry = [record2.industry_code, record2.industry_name].filter(Boolean).join(" ");
+    console.log(
+      publicDataCell(record2.source_id, 21).padEnd(22) + publicDataCell(record2.native_id, 21).padEnd(22) + publicDataCell(record2.entity_name, 41).padEnd(42) + publicDataCell(industry, 27).padEnd(28) + publicDataCell(record2.domain, 23).padEnd(24) + publicDataCell(loc, 11).padEnd(12) + publicDataCell(record2.match_type, 16)
+    );
+  }
+  if (result.next_offset !== null && result.next_offset !== void 0) {
+    console.log(`
+Next page: --offset ${result.next_offset}`);
+  }
+}
+function printPublicDataSources(result) {
+  const sources = Array.isArray(result.sources) ? result.sources : [];
+  console.log(`Public data sources: ${sources.length}/${result.total ?? sources.length}`);
+  if (!sources.length) {
+    console.log("No sources matched.");
+    return;
+  }
+  console.log("");
+  console.log("Source ID".padEnd(30) + "Status".padEnd(12) + "Rung".padEnd(7) + "Join key".padEnd(20) + "Cadence".padEnd(16) + "Name");
+  console.log("-".repeat(120));
+  for (const source of sources) {
+    console.log(
+      publicDataCell(source.id, 29).padEnd(30) + publicDataCell(source.ingestion_status, 11).padEnd(12) + String(source.ground_truth_rung ?? "").padEnd(7) + publicDataCell(source.primary_join_key || source.join_key_quality, 19).padEnd(20) + publicDataCell(source.update_cadence, 15).padEnd(16) + publicDataCell(source.name, 40)
+    );
+  }
+}
+async function publicData(sub, rest) {
+  if (!sub || sub === "--help" || sub === "-h" || sub === "help") {
+    process.stdout.write(`signaliz public-data <search|sources> [options]
+
+Search the public-ground-truth cache of public registry and disclosure data.
+
+Examples:
+  signaliz public-data search --query "swift transportation" --source-id fmcsa_company_census --limit 10
+  signaliz public-data search --industry "software publishers" --location CA --limit 25 --json
+  signaliz public-data search --source-id bls_qcew --naics 541511 --state CA --year 2025 --json
+  signaliz public-data search --domain swifttrans.com --json
+  signaliz public-data search --join-key ein=123456789 --json
+  signaliz public-data sources --status ready --json
+`);
+    return;
+  }
+  const sdk = getSdk();
+  if (!sdk.publicGroundTruth?.search || !sdk.publicGroundTruth?.listSources) {
+    die("Installed @signaliz/sdk does not expose publicGroundTruth yet. Rebuild or upgrade @signaliz/sdk.");
+  }
+  if (sub === "sources" || sub === "list-sources") {
+    const flags2 = parseCommandFlags(rest);
+    const result2 = await sdk.publicGroundTruth.listSources({
+      query: commandStringFlag(flags2, "query", "q", "search"),
+      status: commandStringFlag(flags2, "status"),
+      limit: commandNumberFlag(flags2, "limit")
+    });
+    return output(result2, () => printPublicDataSources(result2));
+  }
+  if (sub !== "search") die("Usage: signaliz public-data <search|sources>");
+  const flags = parseCommandFlags(rest);
+  const query = commandStringFlag(flags, "query", "q", "search") || publicDataPositionalText(rest);
+  const sourceId = commandStringFlag(flags, "source-id", "sourceId");
+  const entityType = commandStringFlag(flags, "entity-type", "entityType");
+  const filters = publicGroundTruthFiltersFromCommandFlags(flags);
+  if (!query && !sourceId && !entityType && Object.keys(filters).length === 0) {
+    die("Usage: signaliz public-data search [--query TEXT] [--industry TEXT] [--location TEXT] [--domain DOMAIN] [--naics CODE] [--join-key k=v]");
+  }
+  const result = await sdk.publicGroundTruth.search({
+    query,
+    sourceId,
+    entityType,
+    ...filters,
+    limit: commandNumberFlag(flags, "limit"),
+    offset: commandNumberFlag(flags, "offset")
+  });
+  return output(result, () => printPublicDataSearchResult(result));
+}
 function normalizeAiRecords(value, source) {
   if (Array.isArray(value)) {
     if (value.every((item) => item && typeof item === "object" && !Array.isArray(item))) {
@@ -2802,12 +2991,47 @@ function aiAttachmentsFromFlags() {
   return attachments;
 }
 async function ai(sub, rest) {
-  if (sub !== "multi-model" && sub !== "multimodel") {
-    die('Usage: signaliz ai multi-model --prompt "..." --confirm-spend');
-  }
   if (flagArg("model") !== void 0 || hasFlag("model") || flagArg("analysis-models") !== void 0 || hasFlag("analysis-models") || flagArg("judge-model") !== void 0 || hasFlag("judge-model")) {
     die("Custom AI model selection is no longer supported. Signaliz-hosted custom AI uses the default model and returns model readback metadata.");
   }
+  if (sub === "fusion") {
+    const promptText2 = promptArg(rest);
+    if (!promptText2) die('Usage: signaliz ai fusion --prompt "..." [--dry-run|--confirm-spend]');
+    const dryRun = hasFlag("dry-run") || !hasFlag("confirm-spend");
+    const sdk2 = getSdk();
+    const result2 = await sdk2.ai.fusion({
+      prompt: promptText2,
+      records: aiRecordsFromFlags(),
+      preset: flagArg("preset") || "general-budget",
+      systemPrompt: flagArg("system-prompt"),
+      temperature: numberFlag("temperature"),
+      maxToolCalls: numberFlag("max-tool-calls"),
+      maxTokens: numberFlag("max-tokens"),
+      timeoutMs: numberFlag("timeout-ms"),
+      dryRun,
+      confirmSpend: !dryRun,
+      maxCredits: numberFlag("max-credits"),
+      maxCostUsd: numberFlag("max-cost-usd"),
+      outputFields: aiOutputFieldsFromFlags()
+    });
+    return output(result2, () => {
+      console.log(dryRun || result2.raw?.dry_run ? "AI Enrichment Fusion dry run" : "AI Enrichment Fusion complete");
+      console.log(`  Model:       ${result2.model || "openrouter/fusion"}`);
+      console.log(`  Preset:      ${String(result2.fusion?.preset || flagArg("preset") || "general-budget")}`);
+      console.log(`  Records:     ${result2.results.length}`);
+      console.log(`  Cost USD:    $${Number(result2.costUsd || 0).toFixed(6)}`);
+      console.log(`  Credits:     ${result2.creditsUsed}`);
+      console.log(`  Tokens:      ${result2.tokensUsed}`);
+      const preview = result2.results.slice(0, 3);
+      if (preview.length) {
+        console.log("\nResults preview:");
+        console.log(JSON.stringify(preview, null, 2));
+      }
+    });
+  }
+  if (sub !== "multi-model" && sub !== "multimodel") {
+    die('Usage: signaliz ai <multi-model|fusion> --prompt "..." --confirm-spend');
+  }
   const promptText = promptArg(rest);
   if (!promptText) die('Usage: signaliz ai multi-model --prompt "..." --confirm-spend');
   if (!hasFlag("confirm-spend")) {
@@ -2844,6 +3068,118 @@ async function ai(sub, rest) {
     }
   });
 }
+function signalCompaniesFromFlags() {
+  const companiesFile = flagArg("companies-file");
+  if (companiesFile) return normalizeAiRecords(readJsonValue(companiesFile), companiesFile);
+  const companiesJson = flagArg("companies-json");
+  if (companiesJson) return normalizeAiRecords(JSON.parse(companiesJson), "--companies-json");
+  return void 0;
+}
+async function signals(sub, rest) {
+  if (sub === "enrich") {
+    const domain2 = flagArg("domain") || flagArg("company-domain");
+    const companyName2 = flagArg("company-name") || rest.find((item) => !item.startsWith("--"));
+    if (!domain2 && !companyName2) {
+      die("Usage: signaliz signals enrich --domain example.com [--target-signal-count 15]");
+    }
+    const sdk2 = getSdk();
+    const result2 = await sdk2.signals.enrichV2({
+      domain: domain2,
+      companyName: companyName2,
+      researchPrompt: flagArg("prompt") || flagArg("research-prompt"),
+      signalTypes: csvFlag("signal-types") || ["all"],
+      targetSignalCount: numberFlag("target-signal-count"),
+      lookbackDays: numberFlag("lookback-days"),
+      online: !hasFlag("offline"),
+      enableDeepSearch: !hasFlag("shallow") && !hasFlag("offline"),
+      skipCache: hasFlag("skip-cache") || hasFlag("fresh-only")
+    });
+    return output(result2, () => {
+      console.log("Company signal enrichment complete");
+      console.log(`  Company:     ${result2.company.name || companyName2 || domain2}`);
+      console.log(`  Signals:     ${result2.signalCount}`);
+      const preview = result2.signals.slice(0, 5);
+      if (preview.length) {
+        console.log("\nPreview:");
+        console.log(JSON.stringify(preview, null, 2));
+      }
+    });
+  }
+  if (sub === "signal-to-copy" || sub === "personalize") {
+    const companyDomain = flagArg("company-domain") || flagArg("domain");
+    const personName = flagArg("person-name") || flagArg("name");
+    const title = flagArg("title");
+    const campaignOffer = flagArg("campaign-offer") || flagArg("offer");
+    if (!companyDomain || !personName || !title || !campaignOffer) {
+      die('Usage: signaliz signals signal-to-copy --company-domain example.com --person-name "Alex Smith" --title "VP Sales" --campaign-offer "sales intelligence platform" [--research-prompt "..."]');
+    }
+    const result2 = await getSdk().signals.signalToCopy({
+      companyDomain,
+      personName,
+      title,
+      campaignOffer,
+      researchPrompt: flagArg("research-prompt") || flagArg("prompt")
+    });
+    return output(result2, () => {
+      console.log(`Signal Copy: ${result2.strongestSignal}`);
+      console.log(`Confidence: ${result2.confidence}`);
+      console.log(`Evidence: ${result2.evidenceUrl}`);
+      for (const variation of result2.variations) {
+        console.log(`
+=== ${variation.style} ===`);
+        console.log(`Subject: ${variation.subjectLine}`);
+        console.log(variation.email || `${variation.openingLine}
+
+${variation.cta}`);
+      }
+    });
+  }
+  if (sub !== "fusion") {
+    die("Usage: signaliz signals <enrich|signal-to-copy|fusion> --domain example.com");
+  }
+  const dryRun = hasFlag("dry-run") || !hasFlag("confirm-spend");
+  const companies = signalCompaniesFromFlags();
+  const domain = flagArg("domain") || flagArg("company-domain");
+  const companyName = flagArg("company-name") || rest.find((item) => !item.startsWith("--"));
+  const linkedinUrl = flagArg("linkedin-url");
+  if (!companies?.length && !domain && !companyName && !linkedinUrl) {
+    die("Usage: signaliz signals fusion --domain example.com [--dry-run|--confirm-spend]");
+  }
+  const sdk = getSdk();
+  const result = await sdk.signals.fusion({
+    companies,
+    domain,
+    companyName,
+    linkedinUrl,
+    preset: flagArg("preset") || "general-budget",
+    researchPrompt: flagArg("prompt") || flagArg("research-prompt"),
+    signalTypes: csvFlag("signal-types"),
+    lookbackDays: numberFlag("lookback-days"),
+    targetSignalCount: numberFlag("target-signal-count"),
+    maxToolCalls: numberFlag("max-tool-calls"),
+    maxTokens: numberFlag("max-tokens"),
+    timeoutMs: numberFlag("timeout-ms"),
+    dryRun,
+    confirmSpend: !dryRun,
+    maxCredits: numberFlag("max-credits"),
+    maxCostUsd: numberFlag("max-cost-usd")
+  });
+  return output(result, () => {
+    console.log(dryRun || result.raw?.dry_run ? "Signal Fusion dry run" : "Signal Fusion complete");
+    console.log(`  Model:       ${result.model || "openrouter/fusion"}`);
+    console.log(`  Preset:      ${String(result.fusion?.preset || flagArg("preset") || "general-budget")}`);
+    console.log(`  Companies:   ${result.results.length || 1}`);
+    console.log(`  Signals:     ${result.signalCount}`);
+    console.log(`  Cost USD:    $${Number(result.costUsd || 0).toFixed(6)}`);
+    console.log(`  Credits:     ${result.creditsUsed}`);
+    console.log(`  Tokens:      ${result.tokensUsed}`);
+    const preview = result.signals.length ? result.signals.slice(0, 5) : result.results.slice(0, 3);
+    if (preview.length) {
+      console.log("\nPreview:");
+      console.log(JSON.stringify(preview, null, 2));
+    }
+  });
+}
 async function campaignBuild() {
   if (isHelpRequest(process.argv.slice(4))) {
     process.stdout.write(campaignHelpFor("build"));
@@ -3093,7 +3429,10 @@ function printCampaignCustomerRowCounts(status) {
   if (!counts || typeof counts !== "object") return;
   const value = (camel, snake) => counts[camel] ?? counts[snake] ?? "n/a";
   const requested = value("requestedTarget", "requested_target");
-  console.log(`Customer rows: accepted ${value("acceptedRows", "accepted_rows")}/${requested}, copied ${value("copiedRows", "copied_rows")}, approval-ready ${value("approvalReadyRows", "approval_ready_rows")}, QA-ready ${value("qaReadyRows", "qa_ready_rows")}, delivered ${value("deliveredRows", "delivered_rows")}`);
+  const copied = value("copiedRows", "copied_rows");
+  const copySkipped = value("copySkippedRows", "copy_skipped_rows");
+  const copyLabel = typeof copySkipped === "number" && copySkipped > 0 && (!copied || copied === "n/a") ? `copy-skipped ${copySkipped}` : `copied ${copied}`;
+  console.log(`Customer rows: accepted ${value("acceptedRows", "accepted_rows")}/${requested}, ${copyLabel}, approval-ready ${value("approvalReadyRows", "approval_ready_rows")}, QA-ready ${value("qaReadyRows", "qa_ready_rows")}, delivered ${value("deliveredRows", "delivered_rows")}`);
   const shortfalls = [
     ["accepted", value("acceptedShortfall", "accepted_shortfall")],
     ["usable", value("usableShortfall", "usable_shortfall")],
@@ -3211,7 +3550,11 @@ function formatCampaignRowsForOperator(rows) {
       disqualifiers: firstArray(data.disqualifiers),
       signal: data.signal_title ? {
         type: data.signal_type || null,
+        family: data.signal_family || data.signal_type || null,
         title: data.signal_title,
+        source_type: data.signal_source_type || data.signal_event_label || data.signal_classification?.label || null,
+        source_provenance: data.signal_source_provenance || data.source_provenance || null,
+        classification: data.signal_classification || null,
         summary: data.signal_summary || null,
         date: data.signal_date || null,
         confidence: data.signal_confidence ?? null,
@@ -3353,10 +3696,10 @@ var CAMPAIGN_AGENT_APPROVAL_TYPES = [
   "launch"
 ];
 var CAMPAIGN_AGENT_TEMPLATE_PLAYBOOKS = {
-  "industrial-ot-resilience": ["net-new-suppressed-list", "proof-first-vertical-gate", "signal-led-copy-approval"],
-  "non-medical-home-care": ["proof-first-vertical-gate", "domain-first-recovery", "table-workflow-handoff"],
-  "agency-founder-led": ["net-new-suppressed-list", "signal-led-copy-approval", "table-workflow-handoff"],
-  "cloud-infrastructure-displacement": ["proof-first-vertical-gate", "domain-first-recovery", "signal-led-copy-approval"]
+  "industrial-ot-resilience": ["net-new-suppressed-list", "proof-first-vertical-gate", "signal-led-copy-approval", "icp-persona-segmentation", "buying-signal-prioritization", "multi-channel-sequence-fit", "revops-feedback-loop"],
+  "non-medical-home-care": ["proof-first-vertical-gate", "domain-first-recovery", "table-workflow-handoff", "icp-persona-segmentation", "buying-signal-prioritization", "multi-channel-sequence-fit", "revops-feedback-loop"],
+  "agency-founder-led": ["net-new-suppressed-list", "signal-led-copy-approval", "table-workflow-handoff", "icp-persona-segmentation", "buying-signal-prioritization", "multi-channel-sequence-fit", "revops-feedback-loop"],
+  "cloud-infrastructure-displacement": ["proof-first-vertical-gate", "domain-first-recovery", "signal-led-copy-approval", "icp-persona-segmentation", "buying-signal-prioritization", "multi-channel-sequence-fit", "revops-feedback-loop"]
 };
 var CAMPAIGN_AGENT_HELP = `signaliz campaign-agent <command> [options]
 
@@ -7162,8 +7505,15 @@ async function main() {
       return tools();
     case "discover":
       return discover(rest);
+    case "public-data":
+    case "ground-truth":
+    case "public-ground-truth":
+      return publicData(rest[0], rest.slice(1));
     case "ai":
       return ai(rest[0], rest.slice(1));
+    case "signal":
+    case "signals":
+      return signals(rest[0], rest.slice(1));
     case "lead":
     case "leads":
       return lead(rest[0], rest.slice(1));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaliz/cli",
-  "version": "1.0.18",
+  "version": "1.0.19",
   "description": "Signaliz CLI — GTM Kernel, Nango routes, MCP, and enrichment operations.",
   "bin": {
     "signaliz": "dist/bin.js"