@socialseal/cli 0.1.7 → 0.1.9

package/src/index.js

@@ -10,14 +10,16 @@ const DEFAULT_CONFIG_PATH = path.join(os.homedir(), '.config', 'socialseal', 'co
 const DEFAULT_API_BASE = 'https://api.socialseal.co';
 const CLI_KEY_HEADER = 'X-CLI-Key';
 const WORKSPACE_HEADER = 'X-Workspace-Id';
-const DEFAULT_TIMEOUT_MS = 30000;
+const DEFAULT_TIMEOUT_MS = 300000;
 const DEFAULT_AGENT_IDLE_TIMEOUT_MS = 300000;
 const DEFAULT_POLL_INTERVAL_MS = 2000;
+const DEFAULT_STATUS_RESULTS_LIMIT = 10;
 const DEFAULT_FRAME_COUNT = 3;
 const MAX_TIMEOUT_MS = 900000;
 const LEGACY_ENABLED = process.env.SOCIALSEAL_ENABLE_LEGACY === '1';
 const CLI_VERSION = loadRuntimeVersion();
 const STATIC_TOOL_REGISTRY_NOTE = 'This registry is shipped with the CLI for stable discovery. It is not live backend enumeration, so environment-specific availability can drift.';
+const STATIC_TOOL_SCHEMA_NOTE = 'Schema hints are static CLI docs for discoverability. Backend contracts can still evolve.';
 const EXIT_CODES = {
   OK: 0,
   UNKNOWN: 1,
@@ -27,8 +29,12 @@ const EXIT_CODES = {
   SERVER: 5,
 };
 const HTTP_METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS']);
+const ACTIVE_STATUS_VALUES = new Set(['queued', 'pending', 'processing', 'in_progress', 'running']);
+const TOOL_STATUS_KINDS = new Set(['auto', 'agent_job', 'google_ai_run', 'journey_run']);
 const REPORT_TYPE_SEARCH_RESULTS_ENRICHED = 'search_results_enriched';
 const EXPORT_DATA_TEMPLATE_TRACKING_RANKED_VIDEOS_RAW = 'tracking_ranked_videos_raw';
+const EXPORT_DATA_TEMPLATE_GOOGLE_AI_SEARCH_SUMMARIES_RAW = 'google_ai_search_summaries_raw';
+const PLATFORM_ID_GOOGLE_AI = 11;
 const SUPPORTED_EXPORT_REPORT_TYPES = [
   'keyword_universe',
   'cluster_insights',
@@ -55,6 +61,14 @@ const EXPORT_OPTIONS = [
     bestFor: 'SQL-like ranked-search datasets without using psql.',
     alias: 'socialseal data export-report --report-type search_results_enriched --format csv --payload @payload.json',
   },
+  {
+    id: 'group_evidence',
+    command: 'socialseal data export-group-evidence --group-id <id> --workspace-id <uuid>',
+    summary: 'Unified group evidence export that routes social groups and Google AI groups to the right raw export template.',
+    formats: ['csv'],
+    required: ['workspace id', '--group-id'],
+    bestFor: 'Automation that needs usable evidence without knowing whether the group is social ranked search or Google AI.',
+  },
   {
     id: 'report_templates',
     command: 'socialseal data export-report --report-type <type> --format <format> --payload @payload.json',
@@ -66,7 +80,17 @@ const EXPORT_OPTIONS = [
   },
 ];
 const KNOWN_TOOLS = [
-  { name: 'agent-tool-jobs', category: 'agent', description: 'Poll queued agent-backed tool jobs and fetch their results.' },
+  {
+    name: 'agent-tool-jobs',
+    category: 'agent',
+    description: 'Queue/poll agent-backed tool jobs.',
+    objectType: 'agent_tool_job',
+    transport: 'post_edge_function',
+    workspaceScoped: true,
+    knownLocalDevState: 'enabled',
+    actionAliases: ['start', 'status'],
+    notes: 'Use action=start to queue and action=status to read a UUID job id.',
+  },
   { name: 'deep-exploration-runs', category: 'agent', description: 'Read or persist deep exploration render runs.' },
   { name: 'workspace-notes', category: 'agent', description: 'Search, create, update, and pin workspace note memory.' },
   { name: 'workspace-onboarding', category: 'agent', description: 'Read or update workspace onboarding metadata used by the agent.' },
@@ -123,7 +147,36 @@ const KNOWN_TOOLS = [
     notes: 'Accepts videoId/videoUid/platformVideoId/searchResultId items; videoId means video_uid or platform-native video id, not a tracking item id.',
   },
   { name: 'douyin-geo-api', category: 'search', description: 'Query Douyin search and geo data.' },
-  { name: 'google-ai-search', category: 'search', description: 'Run Google AI search queries and fetch result snapshots.' },
+  {
+    name: 'google-ai-search',
+    category: 'search',
+    description: 'Queue Google AI search runs.',
+    objectType: 'google_ai_run',
+    transport: 'post_edge_function',
+    workspaceScoped: true,
+    knownLocalDevState: 'enabled',
+    notes: 'Returns numeric runId. Read status/results via get-google-ai-search-runs/get-google-ai-search-results or socialseal tools status <runId>.',
+  },
+  {
+    name: 'get-google-ai-search-runs',
+    category: 'search',
+    description: 'Read Google AI run queue/progress by numeric run id.',
+    objectType: 'google_ai_run',
+    transport: 'post_edge_function',
+    workspaceScoped: true,
+    knownLocalDevState: 'enabled',
+    notes: 'Primary status endpoint for numeric Google AI run ids.',
+  },
+  {
+    name: 'get-google-ai-search-results',
+    category: 'search',
+    description: 'Read Google AI summaries/citations by numeric run id.',
+    objectType: 'google_ai_summary',
+    transport: 'post_edge_function',
+    workspaceScoped: true,
+    knownLocalDevState: 'enabled',
+    notes: 'Use this after a run reaches succeeded/partial/failed to inspect summary-level output.',
+  },
   { name: 'instagram-geo-api', category: 'search', description: 'Query Instagram search and geo data.' },
   { name: 'tiktok-geo-api', category: 'search', description: 'Query TikTok search and geo data.' },
   { name: 'xhs-geo-api', category: 'search', description: 'Query Xiaohongshu search and geo data.' },
@@ -137,7 +190,7 @@ const KNOWN_TOOLS = [
     workspaceScoped: true,
     knownLocalDevState: 'disabled_by_default',
     actionAliases: ['list', 'get', 'create', 'update', 'delete', 'refresh', 'list_items', 'add_item', 'group_add_item', 'add_items', 'group_add_items', 'remove_item', 'group_remove_item'],
-    notes: 'REST-style surface under /groups. `add_item`/`group_add_item` accepts an existing `item_id`; `add_items`/`group_add_items` accepts `item_ids` or item payloads for bulk membership adds. Always pass a workspace id or configure a default workspace so the backend does not fall back to the personal workspace.',
+    notes: 'REST-style surface under /groups. `add_item`/`group_add_item` accepts an existing `item_id`; `add_items`/`group_add_items` accepts `item_ids` or item payloads for bulk membership adds. `completeness` checks expected memberships and refresh queue visibility. Always pass a workspace id or configure a default workspace so the backend does not fall back to the personal workspace.',
   },
   {
     name: 'tracking',
@@ -152,7 +205,16 @@ const KNOWN_TOOLS = [
   },
   { name: 'journey-feedback', category: 'vnext', description: 'Record acceptance or rejection feedback for opportunity bundles.' },
   { name: 'opportunity-bundle-approve', category: 'vnext', description: 'Approve an opportunity bundle and create tracking coverage.' },
-  { name: 'search-journey-run', category: 'vnext', description: 'Run a search journey for a subject across supported platforms.' },
+  {
+    name: 'search-journey-run',
+    category: 'vnext',
+    description: 'Run or poll a search journey for a subject across supported platforms.',
+    objectType: 'search_journey_run',
+    transport: 'post_edge_function',
+    workspaceScoped: true,
+    knownLocalDevState: 'enabled',
+    notes: 'Async start returns runId; poll with action=status or socialseal tools status <runId> --kind journey_run --workspace-id <workspace-id>.',
+  },
   { name: 'vnext-blueprints-create', category: 'vnext', description: 'Create a vNext blueprint from grounded evidence.' },
   { name: 'vnext-blueprints-generate', category: 'vnext', description: 'Generate a vNext blueprint from workspace opportunity data.' },
   { name: 'vnext-blueprints-read', category: 'vnext', description: 'Read vNext blueprint history and specific versions.' },
@@ -168,6 +230,245 @@ const KNOWN_TOOLS = [
   { name: 'vnext-topics-auto-tag', category: 'vnext', description: 'Auto-tag keyword and topic assignments with Gemini-assisted review.' },
 ];
 
+const TOOL_SCHEMA_HINTS = {
+  'agent-tool-jobs': {
+    summary: 'Queue agent-backed jobs and read UUID job status.',
+    operations: [
+      {
+        action: 'start',
+        required: ['action=start', 'toolName', 'payload'],
+        optional: [],
+        example: {
+          action: 'start',
+          toolName: 'search_videos',
+          payload: {
+            query: 'best africa safari itinerary',
+            platform: 'tiktok',
+            region: 'IN',
+            limit: 20,
+          },
+        },
+      },
+      {
+        action: 'status',
+        required: ['action=status', 'jobId (uuid)'],
+        optional: [],
+        example: {
+          action: 'status',
+          jobId: '11111111-1111-4111-8111-111111111111',
+        },
+      },
+    ],
+    cliExamples: [
+      'socialseal tools call --function agent-tool-jobs --body \'{"action":"start","toolName":"search_videos","payload":{"query":"best africa safari itinerary","platform":"tiktok","region":"IN"}}\'',
+      'socialseal tools status 11111111-1111-4111-8111-111111111111 --kind agent_job',
+    ],
+  },
+  'search-journey-run': {
+    summary: 'Start/poll journey keyword expansion runs.',
+    operations: [
+      {
+        action: 'start',
+        required: ['subject', 'subjectType', 'region', 'workspaceId'],
+        optional: [
+          'locale',
+          'platformKeys',
+          'seedKeywords',
+          'contentPillars',
+          'contentPillarIds',
+          'maxKeywords',
+          'maxKeywordsPerStage',
+          'includeRejected',
+          'skipCache',
+          'executionMode',
+        ],
+        example: {
+          subject: 'Como Hotels',
+          subjectType: 'brand',
+          region: 'IN',
+          locale: 'en-IN',
+          workspaceId: '00000000-0000-4000-8000-000000000000',
+          executionMode: 'async',
+        },
+      },
+      {
+        action: 'status',
+        required: ['action=status', 'workspaceId', 'runId (uuid)'],
+        optional: [],
+        example: {
+          action: 'status',
+          workspaceId: '00000000-0000-4000-8000-000000000000',
+          runId: '11111111-1111-4111-8111-111111111111',
+        },
+      },
+    ],
+    cliExamples: [
+      'socialseal tools call --function search-journey-run --body @journey.json --async --workspace-id <workspace-uuid>',
+      'socialseal tools status 11111111-1111-4111-8111-111111111111 --kind journey_run --workspace-id <workspace-uuid>',
+    ],
+  },
+  'google-ai-search': {
+    summary: 'Queue Google AI runs (returns numeric runId).',
+    operations: [
+      {
+        action: 'start',
+        required: ['queries'],
+        optional: [
+          'workspaceId',
+          'trackingItemId',
+          'countryCode',
+          'searchLanguage',
+          'brandId',
+          'competitorBrandIds',
+          'brandDomains',
+          'competitorDomains',
+          'aiMode',
+        ],
+        notes: 'region is commonly used in workflows, but the canonical field is countryCode.',
+        example: {
+          queries: ['east africa itinerary', 'kenya tanzania itinerary'],
+          countryCode: 'in',
+          searchLanguage: 'en',
+          workspaceId: '00000000-0000-4000-8000-000000000000',
+        },
+      },
+    ],
+    cliExamples: [
+      'socialseal tools call --function google-ai-search --body @google-ai-search.json --workspace-id <workspace-uuid>',
+      'socialseal tools status 6809 --kind google_ai_run',
+    ],
+  },
+  'get-google-ai-search-runs': {
+    summary: 'Read Google AI run status/progress.',
+    operations: [
+      {
+        action: 'read',
+        required: [],
+        optional: ['runId', 'trackingItemId', 'limit', 'offset', 'skipCache'],
+        example: {
+          runId: 6809,
+          limit: 1,
+          offset: 0,
+        },
+      },
+    ],
+    cliExamples: [
+      'socialseal tools call --function get-google-ai-search-runs --body \'{"runId":6809,"limit":1}\'',
+      'socialseal tools status 6809 --kind google_ai_run',
+    ],
+  },
+  'get-google-ai-search-results': {
+    summary: 'Read Google AI summary/citation rows.',
+    operations: [
+      {
+        action: 'read',
+        required: [],
+        optional: ['runId', 'query', 'trackingItemId', 'includeCitations', 'limit', 'offset', 'skipCache'],
+        example: {
+          runId: 6809,
+          includeCitations: true,
+          limit: 10,
+          offset: 0,
+        },
+      },
+    ],
+    cliExamples: [
+      'socialseal tools call --function get-google-ai-search-results --body \'{"runId":6809,"includeCitations":true,"limit":10}\'',
+    ],
+  },
+  'group-management': {
+    summary: 'Manage single-platform tracking groups and memberships.',
+    operations: [
+      {
+        action: 'create',
+        required: ['action=create', 'name', 'workspaceId or --workspace-id'],
+        optional: [
+          'platform (defaults to tiktok)',
+          'description',
+          'refresh_frequency',
+          'next_refresh_at',
+          'brand_id',
+        ],
+        notes: 'Supported platform values: tiktok, instagram, youtube, ig_reels, yt_shorts, douyin, xhs, google_ai.',
+        example: {
+          action: 'create',
+          name: 'YouTube competitor searches',
+          platform: 'youtube',
+        },
+      },
+      {
+        action: 'add_items',
+        required: ['action=add_items', 'group_id', 'workspaceId or --workspace-id'],
+        optional: ['item_ids', 'items', 'platform/groupPlatform for item payload defaults'],
+        notes: 'When adding item payloads, omit item platform to inherit the group platform, or pass platform explicitly.',
+        example: {
+          action: 'add_items',
+          group_id: 123,
+          items: [
+            {
+              name: 'best kenya safari',
+              type: 'keyword',
+              value: 'best kenya safari',
+              region: 'US',
+            },
+          ],
+        },
+      },
+      {
+        action: 'completeness',
+        required: ['action=completeness', 'group_id', 'items or expected_items', 'workspaceId or --workspace-id'],
+        optional: ['include_refresh_status'],
+        notes: 'Returns durable setup completeness and aggregate refresh queue status for the group.',
+        example: {
+          action: 'completeness',
+          group_id: 123,
+          expected_items: [
+            {
+              track_type: 'search',
+              track_value: 'best kenya safari',
+              region: 'US',
+            },
+          ],
+        },
+      },
+    ],
+    cliExamples: [
+      'socialseal tools call --function group-management --workspace-id <workspace-uuid> --body \'{"action":"create","name":"YouTube group","platform":"youtube"}\'',
+      'socialseal tools call --function group-management --workspace-id <workspace-uuid> --body \'{"action":"create","name":"Instagram group","platform":"instagram"}\'',
+      'socialseal tools call --function group-management --workspace-id <workspace-uuid> --body \'{"action":"add_items","group_id":123,"items":[{"name":"best kenya safari","type":"keyword","value":"best kenya safari","region":"US"}]}\'',
+    ],
+  },
+};
+
+function getToolSchemaHint(functionName) {
+  if (!functionName) return null;
+  return TOOL_SCHEMA_HINTS[functionName] || null;
+}
+
+function getKnownTool(functionName) {
+  return KNOWN_TOOLS.find((tool) => tool.name === functionName) || null;
+}
+
+function buildSchemaAvailabilitySummary(schema) {
+  const firstOperation = Array.isArray(schema?.operations) ? schema.operations[0] : null;
+  if (!firstOperation || !Array.isArray(firstOperation.required) || firstOperation.required.length === 0) {
+    return 'optional body fields vary by read filter';
+  }
+  return `required: ${firstOperation.required.join(', ')}`;
+}
+
+function buildToolRegistry() {
+  return KNOWN_TOOLS.map((tool) => {
+    const schema = getToolSchemaHint(tool.name);
+    if (!schema) return tool;
+    return {
+      ...tool,
+      schemaAvailable: true,
+      schemaSummary: buildSchemaAvailabilitySummary(schema),
+    };
+  });
+}
+
 function getConfigPath() {
   return process.env.SOCIALSEAL_CONFIG || DEFAULT_CONFIG_PATH;
 }
@@ -723,6 +1024,65 @@ function isUuidLike(value) {
   return typeof value === 'string' && /^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(value.trim());
 }
 
+function isPositiveIntegerString(value) {
+  return typeof value === 'string' && /^[1-9]\d*$/.test(value.trim());
+}
+
+function normalizeStatusIdentifier(rawId) {
+  const id = trimString(rawId);
+  if (!id) {
+    throw new CliError('Missing status identifier.', {
+      code: 'MISSING_ARGUMENT',
+      exitCode: EXIT_CODES.USAGE,
+      hint: 'Pass a numeric Google AI runId or a UUID job/run id.',
+    });
+  }
+
+  if (isPositiveIntegerString(id)) {
+    const parsed = Number(id);
+    if (Number.isSafeInteger(parsed) && parsed > 0) {
+      return { rawId: id, numericId: parsed, uuidId: null };
+    }
+  }
+
+  if (isUuidLike(id)) {
+    return { rawId: id, numericId: null, uuidId: id };
+  }
+
+  throw new CliError(`Unsupported status identifier: ${id}`, {
+    code: 'INVALID_ARGUMENT',
+    exitCode: EXIT_CODES.USAGE,
+    hint: 'Use a numeric Google AI runId (for example 6809) or UUID job/run id.',
+  });
+}
+
+function parseToolStatusKind(rawKind) {
+  const normalized = trimString(rawKind || 'auto').toLowerCase();
+  if (TOOL_STATUS_KINDS.has(normalized)) {
+    return normalized;
+  }
+  throw new CliError(`Unsupported tools status kind: ${rawKind}`, {
+    code: 'INVALID_ARGUMENT',
+    exitCode: EXIT_CODES.USAGE,
+    hint: 'Use --kind auto|agent_job|google_ai_run|journey_run.',
+  });
+}
+
+function normalizeStatusValue(value) {
+  return trimString(value).toLowerCase();
+}
+
+function isTerminalStatusValue(value) {
+  const normalized = normalizeStatusValue(value);
+  if (!normalized) return true;
+  return !ACTIVE_STATUS_VALUES.has(normalized);
+}
+
+function isFailedStatusValue(value) {
+  const normalized = normalizeStatusValue(value);
+  return normalized === 'failed' || normalized === 'error';
+}
+
 function coercePositiveInteger(value, label) {
   if (value === undefined || value === null || value === '') return undefined;
   const parsed = Number(value);
@@ -821,6 +1181,200 @@ function buildSearchResultsEnrichedExportPayload(rawPayload, workspaceId) {
   });
 }
 
+function buildGoogleAiSearchSummariesExportPayload(rawPayload, workspaceId) {
+  const payload = isJsonObject(rawPayload) ? rawPayload : {};
+  const groupId = coercePositiveInteger(firstDefined(payload, ['groupId', 'group_id']), 'groupId');
+  if (!groupId) {
+    throw new CliError('Google AI evidence export requires a group id.', {
+      code: 'MISSING_ARGUMENT',
+      exitCode: EXIT_CODES.USAGE,
+      hint: 'Provide --group-id or groupId in the payload.',
+    });
+  }
+
+  const trackingItemIds = normalizePositiveIntegerList(
+    firstDefined(payload, ['trackingItemIds', 'tracking_item_ids']),
+    'trackingItemIds',
+    { max: 1000 },
+  );
+  const filename = trimString(firstDefined(payload, ['filename'])) || undefined;
+
+  return stripUndefinedEntries({
+    workspaceId,
+    groupId,
+    trackingItemIds: trackingItemIds.length > 0 ? trackingItemIds : undefined,
+    filename,
+  });
+}
+
+function normalizeEvidenceSurface(value) {
+  const normalized = trimString(value || 'auto').toLowerCase().replace(/-/g, '_').replace(/\s+/g, '_');
+  if (['auto', 'social', 'ranked', 'ranked_search', 'google_ai', 'google'].includes(normalized)) {
+    if (normalized === 'ranked' || normalized === 'ranked_search') return 'social';
+    if (normalized === 'google') return 'google_ai';
+    return normalized;
+  }
+  throw new CliError(`Unsupported evidence surface: ${value}`, {
+    code: 'INVALID_ARGUMENT',
+    exitCode: EXIT_CODES.USAGE,
+    hint: 'Use --surface auto|social|google_ai.',
+  });
+}
+
+function normalizePlatformKey(value) {
+  const normalized = trimString(value).toLowerCase().replace(/-/g, '_').replace(/\s+/g, '_');
+  if (!normalized) return null;
+  if (['google', 'google_ai', 'google_ai_overview', 'ai_search'].includes(normalized)) return 'google_ai';
+  return normalized;
+}
+
+function resolveEvidenceSurfaceFromGroup(group) {
+  if (!isJsonObject(group)) return 'social';
+  const platformId = firstDefined(group, ['platform_id', 'platformId']);
+  if (Number(platformId) === PLATFORM_ID_GOOGLE_AI) return 'google_ai';
+  const platform = normalizePlatformKey(firstDefined(group, ['platform', 'platform_key', 'platformKey']));
+  return platform === 'google_ai' ? 'google_ai' : 'social';
+}
+
+function buildGroupEvidenceMetadata({ surface, groupId, workspaceId, responseJson }) {
+  const metadata = isJsonObject(responseJson) && isJsonObject(responseJson.metadata)
+    ? responseJson.metadata
+    : {};
+  const rowCount = Number.isFinite(metadata.row_count) ? metadata.row_count : null;
+  return {
+    group_id: groupId,
+    workspace_id: workspaceId,
+    platform: surface === 'google_ai' ? 'google_ai' : 'social',
+    surface,
+    row_count: rowCount,
+    generated_at: new Date().toISOString(),
+    header_only: rowCount === 0,
+    template: metadata.template ?? (surface === 'google_ai'
+      ? EXPORT_DATA_TEMPLATE_GOOGLE_AI_SEARCH_SUMMARIES_RAW
+      : EXPORT_DATA_TEMPLATE_TRACKING_RANKED_VIDEOS_RAW),
+  };
+}
+
+function normalizeCompletenessPlatform(rawItem) {
+  const platformId = firstDefined(rawItem, ['platform_id', 'platformId']);
+  if (Number.isFinite(Number(platformId))) return `id:${Number(platformId)}`;
+  const platform = normalizePlatformKey(firstDefined(rawItem, ['platform', 'platform_key', 'platformKey']));
+  return platform ? `key:${platform}` : '';
+}
+
+function normalizeCompletenessItem(rawItem, index, source) {
+  if (!isJsonObject(rawItem)) {
+    throw new CliError(`Invalid ${source} item at index ${index}: expected an object.`, {
+      code: 'INVALID_MANIFEST',
+      exitCode: EXIT_CODES.USAGE,
+    });
+  }
+
+  const id = coercePositiveInteger(firstDefined(rawItem, ['item_id', 'itemId', 'id']), `${source}[${index}].item_id`);
+  const rawValue = firstDefined(rawItem, ['track_value', 'trackValue', 'value', 'name']);
+  const value = trimString(rawValue).toLowerCase();
+  const rawType = firstDefined(rawItem, ['track_type', 'trackType', 'type']);
+  const type = normalizeTrackingType(rawType) || trimString(rawType).toLowerCase() || '';
+  const region = trimString(firstDefined(rawItem, ['region'])).toUpperCase();
+  const platform = normalizeCompletenessPlatform(rawItem);
+  const hasSemanticKey = Boolean(value && type);
+  const key = hasSemanticKey ? `${type}|${value}|${region}|${platform}` : `id:${id}`;
+  const looseKey = hasSemanticKey ? `${type}|${value}|${region}` : `id:${id}`;
+
+  if (!id && (!value || !type)) {
+    throw new CliError(`Invalid ${source} item at index ${index}: expected item_id or track_type + track_value.`, {
+      code: 'INVALID_MANIFEST',
+      exitCode: EXIT_CODES.USAGE,
+    });
+  }
+
+  return {
+    key,
+    looseKey,
+    item_id: id ?? null,
+    track_type: type || null,
+    track_value: value || null,
+    region: region || null,
+    platform: platform || null,
+    raw: rawItem,
+  };
+}
+
+function extractExpectedManifestItems(manifest) {
+  if (Array.isArray(manifest)) return manifest;
+  if (!isJsonObject(manifest)) {
+    throw new CliError('Invalid completeness manifest: expected an array or object with items.', {
+      code: 'INVALID_MANIFEST',
+      exitCode: EXIT_CODES.USAGE,
+    });
+  }
+  const items = firstDefined(manifest, ['items', 'expectedItems', 'expected_items']);
+  if (!Array.isArray(items)) {
+    throw new CliError('Invalid completeness manifest: expected items, expectedItems, or expected_items array.', {
+      code: 'INVALID_MANIFEST',
+      exitCode: EXIT_CODES.USAGE,
+    });
+  }
+  return items;
+}
+
+function normalizeActualGroupItem(rawItem, index) {
+  const tracking = isJsonObject(rawItem?.user_tracking) ? rawItem.user_tracking : rawItem;
+  return normalizeCompletenessItem(tracking, index, 'actual_items');
+}
+
+function buildCompletenessDiff({ expectedItems, actualItems, groupId, workspaceId }) {
+  const expected = expectedItems.map((item, index) =>
+    normalizeCompletenessItem(item, index, 'expected_items')
+  );
+  const actual = actualItems.map((item, index) => normalizeActualGroupItem(item, index));
+  const actualByKey = new Map(actual.map((item) => [item.key, item]));
+  const expectedByKey = new Map(expected.map((item) => [item.key, item]));
+  const actualByLooseKey = new Map(actual.map((item) => [item.looseKey, item]));
+  const expectedByLooseKey = new Map(expected.map((item) => [item.looseKey, item]));
+
+  const missing = [];
+  const platformMismatches = [];
+  for (const expectedItem of expected) {
+    if (actualByKey.has(expectedItem.key)) continue;
+    const looseMatch = actualByLooseKey.get(expectedItem.looseKey);
+    if (looseMatch && expectedItem.platform !== looseMatch.platform) {
+      platformMismatches.push({
+        expected: expectedItem.raw,
+        actual: looseMatch.raw,
+        expected_platform: expectedItem.platform,
+        actual_platform: looseMatch.platform,
+      });
+      continue;
+    }
+    missing.push(expectedItem.raw);
+  }
+
+  const extra = [];
+  for (const actualItem of actual) {
+    if (expectedByKey.has(actualItem.key)) continue;
+    const looseMatch = expectedByLooseKey.get(actualItem.looseKey);
+    if (looseMatch && looseMatch.platform !== actualItem.platform) continue;
+    extra.push(actualItem.raw);
+  }
+
+  const complete = missing.length === 0 && extra.length === 0 && platformMismatches.length === 0;
+  return {
+    success: complete,
+    complete,
+    group_id: groupId,
+    workspace_id: workspaceId,
+    expected_count: expected.length,
+    actual_count: actual.length,
+    missing_count: missing.length,
+    extra_count: extra.length,
+    platform_mismatch_count: platformMismatches.length,
+    missing,
+    extra,
+    platform_mismatches: platformMismatches,
+  };
+}
+
 function buildPathWithQuery(basePath, query) {
   const params = new URLSearchParams();
   for (const [key, rawValue] of Object.entries(query || {})) {
@@ -891,8 +1445,10 @@ function normalizeGroupManagementPayload(payload, fallbackWorkspaceId) {
   const itemId = firstDefined(payload, ['item_id', 'itemId']);
   const itemIds = firstDefined(payload, ['item_ids', 'itemIds']);
   const items = firstDefined(payload, ['items']);
+  const expectedItems = firstDefined(payload, ['expected_items', 'expectedItems']);
   const limit = firstDefined(payload, ['limit']);
   const page = firstDefined(payload, ['page']);
+  const force = firstDefined(payload, ['force']);
   return stripUndefinedEntries({
     action: trimString(firstDefined(payload, ['action'])) || undefined,
     workspaceId: resolvePayloadWorkspaceId(payload, fallbackWorkspaceId),
@@ -911,6 +1467,7 @@ function normalizeGroupManagementPayload(payload, fallbackWorkspaceId) {
       })
       : undefined,
     items: Array.isArray(items) ? items : undefined,
+    expected_items: Array.isArray(expectedItems) ? expectedItems : undefined,
     name: trimString(firstDefined(payload, ['name'])) || undefined,
     description: firstDefined(payload, ['description']),
     platform: trimString(firstDefined(payload, ['platform', 'groupPlatform'])) || undefined,
@@ -924,6 +1481,7 @@ function normalizeGroupManagementPayload(payload, fallbackWorkspaceId) {
       : firstDefined(payload, ['region']),
     limit: limit !== undefined ? Number(limit) : undefined,
     page: page !== undefined ? Number(page) : undefined,
+    force: force === true || trimString(force).toLowerCase() === 'true' ? true : undefined,
   });
 }
 
@@ -1413,6 +1971,28 @@ function translateGroupManagementAction(payload, workspaceId, originalMethod) {
     };
   }
 
+  if (action === 'completeness' || action === 'group_completeness') {
+    const groupId = coercePositiveInteger(payload.group_id, 'group_id');
+    if (!groupId) {
+      throw new CliError('group_id is required for group completeness.', {
+        code: 'MISSING_ARGUMENT',
+        exitCode: EXIT_CODES.USAGE,
+      });
+    }
+    const expectedItems = Array.isArray(payload.expected_items)
+      ? payload.expected_items
+      : (Array.isArray(payload.items) ? payload.items : undefined);
+    return {
+      method: 'POST',
+      pathSuffix: buildPathWithQuery(`/groups/${groupId}/completeness`, { workspace_id: workspaceId || undefined }),
+      body: stripUndefinedEntries({
+        expected_items: expectedItems,
+        include_refresh_status: firstDefined(payload, ['include_refresh_status', 'includeRefreshStatus']),
+      }),
+      workspaceId,
+    };
+  }
+
   if (action === 'remove_item' || action === 'group_remove_item') {
     const groupId = coercePositiveInteger(payload.group_id, 'group_id');
     const itemId = coercePositiveInteger(payload.item_id, 'item_id');
@@ -1433,7 +2013,7 @@ function translateGroupManagementAction(payload, workspaceId, originalMethod) {
   throw new CliError(`Unsupported group-management action: ${payload.action}`, {
     code: 'INVALID_ARGUMENT',
     exitCode: EXIT_CODES.USAGE,
-    hint: 'Supported group-management actions: list, get, create, update, delete, refresh, list_items, add_item, add_items, remove_item.',
+    hint: 'Supported group-management actions: list, get, create, update, delete, refresh, list_items, add_item, add_items, completeness, remove_item.',
   });
 }
 
@@ -1722,6 +2302,145 @@ function emitJsonOutput(value, pretty) {
   process.stdout.write(formatJsonOutput(value, pretty) + '\n');
 }
 
+function isGroupManagementBulkAddInvocation(functionName, translated) {
+  if (functionName !== 'group-management') return false;
+  const action = isJsonObject(translated.normalizedPayload)
+    ? trimString(translated.normalizedPayload.action).toLowerCase()
+    : '';
+  return action === 'add_items' || action === 'group_add_items';
+}
+
+function getBulkAddExpectedCount(translated) {
+  return Array.isArray(translated.body) ? translated.body.length : null;
+}
+
+function maybeThrowGroupManagementBulkAddPartialFailure(data, translated) {
+  if (!isJsonObject(data)) return;
+
+  const errors = Array.isArray(data.errors) ? data.errors : [];
+  const expected = getBulkAddExpectedCount(translated);
+  const processed = Number.isFinite(data.items_processed) ? data.items_processed : null;
+  const added = Number.isFinite(data.items_added) ? data.items_added : 0;
+  const linked = Number.isFinite(data.items_linked) ? data.items_linked : 0;
+  const alreadyLinked = Number.isFinite(data.items_already_linked) ? data.items_already_linked : 0;
+  const successful = added + linked + alreadyLinked;
+  const failed = errors.length;
+  const hasErrors = failed > 0;
+  const hasProcessedMismatch = expected !== null && processed !== null && processed !== expected;
+  const hasSuccessMismatch = expected !== null && successful !== expected;
+  const hasVerificationFailure = data.verified === false;
+
+  if (!hasErrors && !hasProcessedMismatch && !hasSuccessMismatch && !hasVerificationFailure) return;
+
+  throw new CliError('group-management add_items partially failed.', {
+    code: 'PARTIAL_FAILURE',
+    exitCode: EXIT_CODES.SERVER,
+    hint: 'Inspect errors[] and re-run add_items after fixing failed items; automation should treat this as an unsuccessful setup.',
+    details: truncateDetails({
+      expected,
+      processed,
+      added,
+      linked,
+      alreadyLinked,
+      successful,
+      failed,
+      verified: data.verified,
+      finalGroupItemCount: data.final_group_item_count,
+      expectedFinalGroupItemCount: data.expected_final_group_item_count,
+      errors,
+      response: data,
+    }),
+  });
+}
+
+function getGroupManagementAction(translated) {
+  return isJsonObject(translated.normalizedPayload)
+    ? trimString(translated.normalizedPayload.action).toLowerCase()
+    : '';
+}
+
+function isGroupManagementRefreshInvocation(functionName, translated) {
+  if (functionName !== 'group-management') return false;
+  const action = getGroupManagementAction(translated);
+  return action === 'refresh' || action === 'group_refresh';
+}
+
+function getGroupManagementGroupId(translated) {
+  return isJsonObject(translated.normalizedPayload)
+    ? coercePositiveInteger(translated.normalizedPayload.group_id, 'group_id')
+    : undefined;
+}
+
+function getGroupItemsCount(data) {
+  if (Array.isArray(data)) return data.length;
+  if (!isJsonObject(data)) return null;
+  if (Number.isFinite(data.total)) return data.total;
+  if (Array.isArray(data.items)) return data.items.length;
+  if (Array.isArray(data.data)) return data.data.length;
+  return null;
+}
+
+async function preflightGroupRefreshNotEmpty({
+  opts,
+  translated,
+  apiBase,
+  apiKey,
+  pathPrefix,
+  workspaceId,
+  timeoutMs,
+}) {
+  if (!isGroupManagementRefreshInvocation(opts.function, translated)) return;
+  if (translated.normalizedPayload?.force === true) return;
+
+  const groupId = getGroupManagementGroupId(translated);
+  if (!groupId) return;
+
+  const res = await callApi({
+    apiBase,
+    apiKey,
+    path: `${pathPrefix}/groups/${groupId}/items?${new URLSearchParams({
+      workspace_id: workspaceId,
+      page: '1',
+      limit: '1',
+    }).toString()}`,
+    method: 'GET',
+    workspaceId,
+    timeoutMs,
+  });
+
+  if (!res.ok) {
+    throw await buildHttpError(res, {
+      label: 'Group refresh preflight',
+      functionName: 'group-management',
+      method: 'GET',
+    });
+  }
+
+  const contentType = res.headers.get('content-type') || '';
+  if (!contentType.includes('application/json')) {
+    throw new CliError('Group refresh preflight returned a non-JSON response.', {
+      code: 'INVALID_RESPONSE',
+      exitCode: EXIT_CODES.SERVER,
+    });
+  }
+
+  const data = await res.json();
+  const itemCount = getGroupItemsCount(data);
+  if (itemCount === 0) {
+    throw new CliError('Refusing to refresh an empty tracking group.', {
+      code: 'EMPTY_GROUP_REFRESH',
+      exitCode: EXIT_CODES.USAGE,
+      hint: 'Add items to the group first, or pass force:true in the group-management payload to override.',
+      details: truncateDetails({
+        groupId,
+        workspaceId,
+        itemCount,
+        response: data,
+      }),
+    });
+  }
+}
+
 function buildSearchJourneyRunFailure(data) {
   const message = isJsonObject(data) && typeof data.error === 'string' && data.error.trim().length > 0
     ? data.error
@@ -1799,14 +2518,17 @@ async function pollSearchJourneyRun({
 
     const data = await res.json();
     const status = isJsonObject(data) && typeof data.status === 'string' ? data.status : null;
+    const normalizedStatus = normalizeStatusValue(status);
     if (status && status !== lastStatus) {
       emitInfo(opts, `search-journey-run status: ${status}`);
       lastStatus = status;
     }
 
-    if (status === 'completed') return data;
-    if (status === 'failed') throw buildSearchJourneyRunFailure(data);
-    if (status === 'pending' || status === 'processing') continue;
+    if (normalizedStatus === 'completed' || normalizedStatus === 'succeeded') return data;
+    if (normalizedStatus === 'failed' || normalizedStatus === 'error') {
+      throw buildSearchJourneyRunFailure(data);
+    }
+    if (normalizedStatus && ACTIVE_STATUS_VALUES.has(normalizedStatus)) continue;
 
     throw new CliError('search-journey-run status poll returned an unexpected payload.', {
       code: 'INVALID_STATUS_RESPONSE',
@@ -1885,22 +2607,444 @@ async function buildHttpError(res, context = {}) {
   });
 }
 
-function emitError(err, opts = {}) {
-  const showDetails = opts.json || opts.verbose;
-  const payload = {
-    type: 'error',
-    error: {
-      code: err.code || 'CLI_ERROR',
-      message: err.message || 'Unknown error',
-      status: err.status ?? null,
-      hint: err.hint ?? null,
-      details: showDetails ? (err.details ?? null) : null,
-    },
-  };
-
-  if (opts.json) {
-    process.stderr.write(`${JSON.stringify(payload)}\n`);
-    return;
+function resolveStatusResultsLimit(rawLimit) {
+  if (rawLimit == null || rawLimit === '') return DEFAULT_STATUS_RESULTS_LIMIT;
+  const parsed = Number(rawLimit);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new CliError('Invalid results limit. Use a positive integer.', {
+      code: 'INVALID_ARGUMENT',
+      exitCode: EXIT_CODES.USAGE,
+      hint: 'Use --results-limit <n> where n is between 1 and 50.',
+    });
+  }
+  return Math.min(parsed, 50);
+}
+
+async function callToolJson({
+  apiBase,
+  apiKey,
+  useGateway,
+  legacyUrl,
+  functionName,
+  body,
+  workspaceId,
+  timeoutMs,
+  label,
+}) {
+  const path = useGateway ? `/cli/tools/${functionName}` : `/functions/v1/${functionName}`;
+  const res = await callApi({
+    apiBase: useGateway ? apiBase : legacyUrl,
+    apiKey,
+    path,
+    method: 'POST',
+    body,
+    workspaceId,
+    timeoutMs,
+  });
+
+  if (res.status === 404) {
+    return { notFound: true, data: null };
+  }
+  if (!res.ok) {
+    throw await buildHttpError(res, {
+      label,
+      functionName,
+      method: 'POST',
+    });
+  }
+
+  const contentType = res.headers.get('content-type') || '';
+  if (!contentType.includes('application/json')) {
+    throw new CliError(`${label} returned a non-JSON response.`, {
+      code: 'INVALID_RESPONSE',
+      exitCode: EXIT_CODES.SERVER,
+    });
+  }
+
+  return { notFound: false, data: await res.json() };
+}
+
+async function readAgentToolJobStatus({
+  apiBase,
+  apiKey,
+  useGateway,
+  legacyUrl,
+  timeoutMs,
+  jobId,
+}) {
+  const response = await callToolJson({
+    apiBase,
+    apiKey,
+    useGateway,
+    legacyUrl,
+    functionName: 'agent-tool-jobs',
+    body: { action: 'status', jobId },
+    workspaceId: null,
+    timeoutMs,
+    label: 'Agent tool job status',
+  });
+  if (response.notFound) return null;
+
+  const data = response.data;
+  return {
+    kind: 'agent_tool_job',
+    id: jobId,
+    status: isJsonObject(data) ? trimString(data.status || '') : '',
+    workspaceId: isJsonObject(data) ? (data.workspaceId ?? null) : null,
+    toolName: isJsonObject(data) ? (data.toolName ?? null) : null,
+    result: isJsonObject(data) ? (data.result ?? null) : null,
+    error: isJsonObject(data) ? (data.error ?? null) : null,
+    raw: data,
+  };
+}
+
+async function readSearchJourneyRunStatus({
+  apiBase,
+  apiKey,
+  useGateway,
+  legacyUrl,
+  timeoutMs,
+  workspaceId,
+  runId,
+}) {
+  if (!workspaceId) {
+    throw new CliError('Search journey run status requires a workspace id.', {
+      code: 'WORKSPACE_REQUIRED',
+      exitCode: EXIT_CODES.USAGE,
+      hint: 'Pass --workspace-id, set SOCIALSEAL_WORKSPACE_ID, or configure a default workspace.',
+    });
+  }
+
+  const response = await callToolJson({
+    apiBase,
+    apiKey,
+    useGateway,
+    legacyUrl,
+    functionName: 'search-journey-run',
+    body: { action: 'status', workspaceId, runId },
+    workspaceId,
+    timeoutMs,
+    label: 'Search journey status',
+  });
+  if (response.notFound) return null;
+
+  const data = response.data;
+  return {
+    kind: 'search_journey_run',
+    id: runId,
+    status: isJsonObject(data) ? trimString(data.status || '') : '',
+    workspaceId,
+    journeyId: isJsonObject(data) ? (data.journeyId ?? null) : null,
+    stagedKeywordsCount:
+      isJsonObject(data) && Array.isArray(data.stagedKeywords) ? data.stagedKeywords.length : 0,
+    error: isJsonObject(data) ? (data.error ?? null) : null,
+    raw: data,
+  };
+}
+
+async function readGoogleAiRunStatus({
+  apiBase,
+  apiKey,
+  useGateway,
+  legacyUrl,
+  timeoutMs,
+  runId,
+  includeResults,
+  resultsLimit,
+}) {
+  const runsResponse = await callToolJson({
+    apiBase,
+    apiKey,
+    useGateway,
+    legacyUrl,
+    functionName: 'get-google-ai-search-runs',
+    body: {
+      runId,
+      limit: 1,
+      offset: 0,
+    },
+    workspaceId: null,
+    timeoutMs,
+    label: 'Google AI run status',
+  });
+  if (runsResponse.notFound) return null;
+
+  const runsPayload = runsResponse.data;
+  const runItem = isJsonObject(runsPayload) && Array.isArray(runsPayload.items)
+    ? runsPayload.items.find((item) => isJsonObject(item) && Number(item.id) === runId) || null
+    : null;
+
+  if (!runItem) return null;
+
+  let resultsPayload = null;
+  if (includeResults) {
+    const resultsResponse = await callToolJson({
+      apiBase,
+      apiKey,
+      useGateway,
+      legacyUrl,
+      functionName: 'get-google-ai-search-results',
+      body: {
+        runId,
+        includeCitations: true,
+        limit: resultsLimit,
+        offset: 0,
+      },
+      workspaceId: null,
+      timeoutMs,
+      label: 'Google AI run results',
+    });
+    resultsPayload = resultsResponse.notFound ? null : resultsResponse.data;
+  }
+
+  return {
+    kind: 'google_ai_run',
+    id: runId,
+    status: trimString(runItem.status || ''),
+    progress: {
+      completedQueries: typeof runItem.completedQueries === 'number' ? runItem.completedQueries : null,
+      totalQueries: typeof runItem.totalQueries === 'number' ? runItem.totalQueries : null,
+      progressPercent: typeof runItem.progressPercent === 'number' ? runItem.progressPercent : null,
+    },
+    lastErrorMessage: runItem.lastErrorMessage ?? null,
+    run: runItem,
+    results: resultsPayload,
+  };
+}
+
+function buildToolStatusNotFoundError(identifier, kind, workspaceId) {
+  if (kind === 'google_ai_run') {
+    return new CliError(`Google AI run not found: ${identifier.rawId}`, {
+      code: 'STATUS_NOT_FOUND',
+      exitCode: EXIT_CODES.NOT_FOUND,
+      hint: 'Verify the run id and key scope, then retry with --kind google_ai_run.',
+    });
+  }
+  if (kind === 'agent_job') {
+    return new CliError(`Agent tool job not found: ${identifier.rawId}`, {
+      code: 'STATUS_NOT_FOUND',
+      exitCode: EXIT_CODES.NOT_FOUND,
+      hint: 'Verify the UUID job id, then retry with --kind agent_job.',
+    });
+  }
+  if (kind === 'journey_run') {
+    return new CliError(`Search journey run not found: ${identifier.rawId}`, {
+      code: 'STATUS_NOT_FOUND',
+      exitCode: EXIT_CODES.NOT_FOUND,
+      hint: 'Verify --workspace-id and the journey run UUID, then retry.',
+    });
+  }
+  return new CliError(`No matching status record found for ${identifier.rawId}.`, {
+    code: 'STATUS_NOT_FOUND',
+    exitCode: EXIT_CODES.NOT_FOUND,
+    hint: workspaceId
+      ? 'Try --kind agent_job or --kind journey_run explicitly.'
+      : 'Try --kind agent_job or provide --workspace-id to also check journey runs.',
+  });
+}
+
+async function resolveUnifiedToolStatus({
+  apiBase,
+  apiKey,
+  useGateway,
+  legacyUrl,
+  timeoutMs,
+  identifier,
+  kind,
+  workspaceId,
+  includeResults,
+  resultsLimit,
+}) {
+  if (kind === 'google_ai_run') {
+    if (identifier.numericId == null) {
+      throw new CliError('google_ai_run status expects a numeric run id.', {
+        code: 'INVALID_ARGUMENT',
+        exitCode: EXIT_CODES.USAGE,
+      });
+    }
+    const result = await readGoogleAiRunStatus({
+      apiBase,
+      apiKey,
+      useGateway,
+      legacyUrl,
+      timeoutMs,
+      runId: identifier.numericId,
+      includeResults,
+      resultsLimit,
+    });
+    if (result) return result;
+    throw buildToolStatusNotFoundError(identifier, kind, workspaceId);
+  }
+
+  if (kind === 'agent_job') {
+    if (!identifier.uuidId) {
+      throw new CliError('agent_job status expects a UUID id.', {
+        code: 'INVALID_ARGUMENT',
+        exitCode: EXIT_CODES.USAGE,
+      });
+    }
+    const result = await readAgentToolJobStatus({
+      apiBase,
+      apiKey,
+      useGateway,
+      legacyUrl,
+      timeoutMs,
+      jobId: identifier.uuidId,
+    });
+    if (result) return result;
+    throw buildToolStatusNotFoundError(identifier, kind, workspaceId);
+  }
+
+  if (kind === 'journey_run') {
+    if (!identifier.uuidId) {
+      throw new CliError('journey_run status expects a UUID run id.', {
+        code: 'INVALID_ARGUMENT',
+        exitCode: EXIT_CODES.USAGE,
+      });
+    }
+    const result = await readSearchJourneyRunStatus({
+      apiBase,
+      apiKey,
+      useGateway,
+      legacyUrl,
+      timeoutMs,
+      workspaceId,
+      runId: identifier.uuidId,
+    });
+    if (result) return result;
+    throw buildToolStatusNotFoundError(identifier, kind, workspaceId);
+  }
+
+  if (identifier.numericId != null) {
+    const result = await readGoogleAiRunStatus({
+      apiBase,
+      apiKey,
+      useGateway,
+      legacyUrl,
+      timeoutMs,
+      runId: identifier.numericId,
+      includeResults,
+      resultsLimit,
+    });
+    if (result) return result;
+    throw buildToolStatusNotFoundError(identifier, 'google_ai_run', workspaceId);
+  }
+
+  const agentJob = await readAgentToolJobStatus({
+    apiBase,
+    apiKey,
+    useGateway,
+    legacyUrl,
+    timeoutMs,
+    jobId: identifier.uuidId,
+  });
+  if (agentJob) return agentJob;
+
+  if (workspaceId) {
+    const journeyRun = await readSearchJourneyRunStatus({
+      apiBase,
+      apiKey,
+      useGateway,
+      legacyUrl,
+      timeoutMs,
+      workspaceId,
+      runId: identifier.uuidId,
+    });
+    if (journeyRun) return journeyRun;
+  }
+
+  throw buildToolStatusNotFoundError(identifier, 'auto', workspaceId);
+}
+
+function buildStatusCommandHint(result, workspaceId) {
+  if (!result || !result.kind) return null;
+  if (result.kind === 'google_ai_run') {
+    return `socialseal tools status ${result.id} --kind google_ai_run`;
+  }
+  if (result.kind === 'agent_tool_job') {
+    return `socialseal tools status ${result.id} --kind agent_job`;
+  }
+  if (result.kind === 'search_journey_run') {
+    const scopedWorkspace = workspaceId || result.workspaceId;
+    if (!scopedWorkspace) return null;
+    return `socialseal tools status ${result.id} --kind journey_run --workspace-id ${scopedWorkspace}`;
+  }
+  return null;
+}
+
+function maybeEmitFollowupStatusHint({ functionName, data, workspaceId }) {
+  if (!isJsonObject(data)) return;
+  if (functionName === 'google-ai-search' && Number.isInteger(data.runId)) {
+    process.stderr.write(
+      `[socialseal] Google AI run queued: ${data.runId}. Use: socialseal tools status ${data.runId} --kind google_ai_run\n`,
+    );
+    return;
+  }
+  if (functionName === 'agent-tool-jobs' && typeof data.jobId === 'string' && isUuidLike(data.jobId)) {
+    process.stderr.write(
+      `[socialseal] Agent tool job queued: ${data.jobId}. Use: socialseal tools status ${data.jobId} --kind agent_job\n`,
+    );
+    return;
+  }
+  if (functionName === 'search-journey-run' && typeof data.runId === 'string' && isUuidLike(data.runId)) {
+    const scopedWorkspace = trimString(workspaceId || data.workspaceId || '');
+    const workspaceFlag = scopedWorkspace ? ` --workspace-id ${scopedWorkspace}` : '';
+    process.stderr.write(
+      `[socialseal] Search journey run id: ${data.runId}. Use: socialseal tools status ${data.runId} --kind journey_run${workspaceFlag}\n`,
+    );
+  }
+}
+
+async function pollUnifiedStatus({
+  loader,
+  timeoutMs,
+  pollIntervalMs,
+  opts,
+}) {
+  const deadline = Date.now() + timeoutMs;
+  let current = await loader();
+  let lastStatus = normalizeStatusValue(current?.status);
+
+  while (!isTerminalStatusValue(current?.status)) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new CliError('Timed out waiting for status completion.', {
+        code: 'ASYNC_WAIT_TIMEOUT',
+        exitCode: EXIT_CODES.SERVER,
+        hint: 'Increase --timeout <ms> or omit --wait to return current status immediately.',
+        details: truncateDetails(current),
+      });
+    }
+
+    emitInfo(opts, `status: ${current.status}`);
+    await sleep(Math.min(pollIntervalMs, remainingMs));
+    current = await loader();
+    const normalized = normalizeStatusValue(current?.status);
+    if (normalized && normalized !== lastStatus) {
+      emitInfo(opts, `status: ${current.status}`);
+      lastStatus = normalized;
+    }
+  }
+
+  return current;
+}
+
+function emitError(err, opts = {}) {
+  const showDetails = opts.json || opts.verbose;
+  const payload = {
+    type: 'error',
+    error: {
+      code: err.code || 'CLI_ERROR',
+      message: err.message || 'Unknown error',
+      status: err.status ?? null,
+      hint: err.hint ?? null,
+      details: showDetails ? (err.details ?? null) : null,
+    },
+  };
+
+  if (opts.json) {
+    process.stderr.write(`${JSON.stringify(payload)}\n`);
+    return;
   }
 
   process.stderr.write(`[socialseal] ${payload.error.message}\n`);
@@ -2480,6 +3624,18 @@ async function handleToolsCall(opts) {
     method,
   });
 
+  if (isGroupManagementRefreshInvocation(opts.function, translated)) {
+    await preflightGroupRefreshNotEmpty({
+      opts,
+      translated,
+      apiBase: useGateway ? resolvedApiBase : legacyUrl,
+      apiKey,
+      pathPrefix: useGateway ? '/cli/tools/group-management' : '/functions/v1/group-management',
+      workspaceId: effectiveWorkspaceId,
+      timeoutMs,
+    });
+  }
+
   const res = await callApi({
     apiBase: useGateway ? resolvedApiBase : legacyUrl,
     apiKey,
@@ -2503,6 +3659,14 @@ async function handleToolsCall(opts) {
     const data = await res.json();
     const shouldPoll = shouldHandleSearchJourneyRunAsync(opts.function, method, payload, opts) && opts.poll !== false;
     if (!shouldPoll) {
+      if (isGroupManagementBulkAddInvocation(opts.function, translated)) {
+        maybeThrowGroupManagementBulkAddPartialFailure(data, translated);
+      }
+      maybeEmitFollowupStatusHint({
+        functionName: opts.function,
+        data,
+        workspaceId: effectiveWorkspaceId,
+      });
       emitJsonOutput(data, opts.pretty);
       return;
     }
@@ -2530,9 +3694,7 @@ async function handleToolsCall(opts) {
       apiBase: useGateway ? resolvedApiBase : legacyUrl,
       apiKey,
       path: useGateway ? `/cli/tools/${opts.function}` : `/functions/v1/${opts.function}`,
-      workspaceId: isJsonObject(payload) && typeof payload.workspaceId === 'string'
-        ? payload.workspaceId
-        : resolvedWorkspaceId,
+      workspaceId: effectiveWorkspaceId,
       timeoutMs,
       pollIntervalMs: resolvePollIntervalMs(opts),
       runId,
@@ -2548,10 +3710,12 @@ async function handleToolsCall(opts) {
 }
 
 function handleToolsList(opts) {
+  const tools = buildToolRegistry();
   const payload = {
     discovery: 'built_in_registry',
-    tools: KNOWN_TOOLS,
+    tools,
     note: STATIC_TOOL_REGISTRY_NOTE,
+    schemaNote: STATIC_TOOL_SCHEMA_NOTE,
   };
 
   if (opts.json) {
@@ -2561,9 +3725,10 @@ function handleToolsList(opts) {
 
   process.stdout.write('[socialseal] Built-in tool registry\n');
   process.stdout.write(`[socialseal] ${payload.note}\n`);
+  process.stdout.write(`[socialseal] ${payload.schemaNote}\n`);
 
   let currentCategory = null;
-  for (const tool of KNOWN_TOOLS) {
+  for (const tool of tools) {
     if (tool.category !== currentCategory) {
       currentCategory = tool.category;
       process.stdout.write(`\n${currentCategory}\n`);
@@ -2578,9 +3743,156 @@ function handleToolsList(opts) {
     if (tool.notes) {
       process.stdout.write(`  note: ${tool.notes}\n`);
     }
+    if (tool.schemaAvailable) {
+      process.stdout.write(`  schema: ${tool.schemaSummary}\n`);
+      process.stdout.write(`  schema command: socialseal tools schema --function ${tool.name}\n`);
+    }
+  }
+
+  process.stdout.write('\n[socialseal] Call a tool with: socialseal tools call --function <name> --body @payload.json\n');
+  process.stdout.write('[socialseal] Inspect schema examples with: socialseal tools schema --function <name>\n');
+}
+
+function handleToolsSchema(opts) {
+  const tools = buildToolRegistry();
+  const functionName = trimString(opts.function || '');
+
+  if (!functionName) {
+    const payload = {
+      note: STATIC_TOOL_SCHEMA_NOTE,
+      schemas: tools
+        .filter((tool) => tool.schemaAvailable)
+        .map((tool) => ({
+          function: tool.name,
+          summary: tool.schemaSummary,
+          details: getToolSchemaHint(tool.name),
+        })),
+    };
+
+    if (opts.json) {
+      emitJsonOutput(payload, opts.pretty);
+      return;
+    }
+
+    process.stdout.write('[socialseal] Tool schema hints\n');
+    process.stdout.write(`[socialseal] ${payload.note}\n`);
+    for (const schemaEntry of payload.schemas) {
+      process.stdout.write(`- ${schemaEntry.function}: ${schemaEntry.summary}\n`);
+      process.stdout.write(`  command: socialseal tools schema --function ${schemaEntry.function}\n`);
+    }
+    return;
+  }
+
+  const knownTool = getKnownTool(functionName);
+  if (!knownTool) {
+    throw new CliError(`Unknown tool: ${functionName}`, {
+      code: 'INVALID_ARGUMENT',
+      exitCode: EXIT_CODES.USAGE,
+      hint: 'Run `socialseal tools list` to discover available tool names.',
+    });
+  }
+
+  const schema = getToolSchemaHint(functionName);
+  if (!schema) {
+    throw new CliError(`No schema hint is bundled for ${functionName}.`, {
+      code: 'SCHEMA_NOT_AVAILABLE',
+      exitCode: EXIT_CODES.NOT_FOUND,
+      hint: 'Use `socialseal tools call --function <tool> --body @payload.json` and inspect backend validation errors for this tool.',
+    });
+  }
+
+  const payload = {
+    function: functionName,
+    note: STATIC_TOOL_SCHEMA_NOTE,
+    schema,
+  };
+
+  if (opts.json) {
+    emitJsonOutput(payload, opts.pretty);
+    return;
+  }
+
+  process.stdout.write(`[socialseal] Tool schema: ${functionName}\n`);
+  process.stdout.write(`[socialseal] ${payload.note}\n`);
+  process.stdout.write(`summary: ${schema.summary}\n`);
+  if (Array.isArray(schema.operations) && schema.operations.length > 0) {
+    process.stdout.write('operations:\n');
+    for (const operation of schema.operations) {
+      process.stdout.write(`- ${operation.action}\n`);
+      if (Array.isArray(operation.required) && operation.required.length > 0) {
+        process.stdout.write(`  required: ${operation.required.join(', ')}\n`);
+      }
+      if (Array.isArray(operation.optional) && operation.optional.length > 0) {
+        process.stdout.write(`  optional: ${operation.optional.join(', ')}\n`);
+      }
+      if (operation.notes) {
+        process.stdout.write(`  note: ${operation.notes}\n`);
+      }
+      if (operation.example) {
+        process.stdout.write(`  example body: ${JSON.stringify(operation.example)}\n`);
+      }
+    }
   }
+  if (Array.isArray(schema.cliExamples) && schema.cliExamples.length > 0) {
+    process.stdout.write('cli examples:\n');
+    for (const example of schema.cliExamples) {
+      process.stdout.write(`- ${example}\n`);
+    }
+  }
+}
 
-  process.stdout.write('\n[socialseal] Call a tool with: socialseal tools call --function <name> --body @payload.json\n');
+async function handleToolsStatus(opts) {
+  const config = loadConfig();
+  const apiKey = requireApiKey(opts, config);
+  const apiBase = resolveApiBase(opts, config);
+  const supabaseUrl = resolveLegacyUrl(resolveSupabaseUrl(opts, config), 'SOCIALSEAL_SUPABASE_URL');
+  const { resolvedApiBase, legacyUrl, useGateway } = resolveApiTarget({ apiBase, legacyUrl: supabaseUrl });
+  const timeoutMs = resolveTimeoutMs(opts, config);
+  const pollIntervalMs = resolvePollIntervalMs(opts);
+  const includeResults = opts.includeResults === true;
+  const resultsLimit = resolveStatusResultsLimit(opts.resultsLimit);
+  const kind = parseToolStatusKind(opts.kind);
+  const identifier = normalizeStatusIdentifier(opts.id);
+  const { workspaceId } = resolveWorkspaceSelection(opts, config);
+
+  const loadStatus = async () =>
+    await resolveUnifiedToolStatus({
+      apiBase: resolvedApiBase,
+      apiKey,
+      useGateway,
+      legacyUrl,
+      timeoutMs,
+      identifier,
+      kind,
+      workspaceId,
+      includeResults,
+      resultsLimit,
+    });
+
+  let result = await loadStatus();
+  if (opts.wait) {
+    result = await pollUnifiedStatus({
+      loader: loadStatus,
+      timeoutMs,
+      pollIntervalMs,
+      opts,
+    });
+  }
+
+  const commandHint = buildStatusCommandHint(result, workspaceId);
+  const payload = {
+    ...result,
+    hint: commandHint,
+  };
+  if (opts.wait && isFailedStatusValue(result.status)) {
+    throw new CliError(`${result.kind} reached terminal ${result.status} status.`, {
+      code: 'STATUS_FAILED',
+      exitCode: EXIT_CODES.SERVER,
+      hint: commandHint,
+      details: truncateDetails(payload),
+    });
+  }
+  emitJsonOutput(payload, opts.pretty);
 }
 
 async function handleDataExportTracking(opts) {
@@ -2733,46 +4045,27 @@ async function handleDataExportReport(opts) {
   process.stdout.write(JSON.stringify(json, null, opts.pretty ? 2 : 0) + '\n');
 }
 
-async function handleDataExportSearchResults(opts) {
-  const config = loadConfig();
-  const apiKey = requireApiKey(opts, config);
-  const apiBase = resolveApiBase(opts, config);
-  const supabaseUrl = resolveLegacyUrl(resolveSupabaseUrl(opts, config), 'SOCIALSEAL_SUPABASE_URL');
-  const { resolvedApiBase, legacyUrl, useGateway } = resolveApiTarget({ apiBase, legacyUrl: supabaseUrl });
-  const timeoutMs = resolveTimeoutMs(opts, config);
-  const { workspaceId: resolvedWorkspaceId, source: workspaceSource } = resolveWorkspaceSelection(opts, config);
-
-  const rawPayload = opts.__rawPayload ?? stripUndefinedEntries({
-    groupIds: normalizePositiveIntegerList(opts.groupIds, 'groupIds', { max: 100 }),
-    trackingItemIds: normalizePositiveIntegerList(opts.trackingItemIds, 'trackingItemIds', { max: 1000 }),
-    dateFrom: opts.dateFrom,
-    dateTo: opts.dateTo,
-    filename: opts.filename,
-  });
-
-  const payloadWorkspaceId = resolvePayloadWorkspaceId(rawPayload, null);
-  const effectiveWorkspaceId = requireWorkspaceSelection(payloadWorkspaceId || resolvedWorkspaceId, {
-    label: 'Search results enriched export',
-    hint: 'Pass --workspace-id, set SOCIALSEAL_WORKSPACE_ID, or configure a default workspace before exporting.',
-  });
-  const effectiveWorkspaceSource = payloadWorkspaceId ? 'body' : workspaceSource;
-  emitWorkspaceSelectionNotice(opts, {
-    workspaceId: effectiveWorkspaceId,
-    source: effectiveWorkspaceSource,
-    label: 'search_results_enriched export',
-  });
-
-  const normalizedPayload = buildSearchResultsEnrichedExportPayload(rawPayload, effectiveWorkspaceId);
-  const requestedFilename = trimString(normalizedPayload.filename) || undefined;
-  delete normalizedPayload.filename;
-
+async function runExportDataCsv({
+  opts,
+  label,
+  template,
+  normalizedPayload,
+  requestedFilename,
+  effectiveWorkspaceId,
+  apiBase,
+  apiKey,
+  useGateway,
+  legacyUrl,
+  timeoutMs,
+  decorateResponse,
+}) {
   const exportResponse = await callApi({
-    apiBase: useGateway ? resolvedApiBase : legacyUrl,
+    apiBase: useGateway ? apiBase : legacyUrl,
     apiKey,
     path: useGateway ? '/cli/tools/export-data' : '/functions/v1/export-data',
     method: 'POST',
     body: {
-      template: EXPORT_DATA_TEMPLATE_TRACKING_RANKED_VIDEOS_RAW,
+      template,
       format: 'csv',
       payload: normalizedPayload,
       filename: requestedFilename,
@@ -2783,13 +4076,16 @@ async function handleDataExportSearchResults(opts) {
 
   if (!exportResponse.ok) {
     throw await buildHttpError(exportResponse, {
-      label: 'Search results enriched export',
+      label,
       functionName: 'export-data',
       method: 'POST',
     });
   }
 
   const responseJson = await exportResponse.json();
+  const decoratedResponse = typeof decorateResponse === 'function'
+    ? decorateResponse(responseJson)
+    : responseJson;
   const metadata = isJsonObject(responseJson) && isJsonObject(responseJson.metadata)
     ? responseJson.metadata
     : null;
@@ -2804,7 +4100,7 @@ async function handleDataExportSearchResults(opts) {
     } else {
       process.stderr.write('[socialseal] Export did not include a file URL yet. Inspect the JSON metadata and retry if needed.\n');
     }
-    emitJsonOutput(responseJson, opts.pretty);
+    emitJsonOutput(decoratedResponse, opts.pretty);
     return;
   }
 
@@ -2815,7 +4111,7 @@ async function handleDataExportSearchResults(opts) {
 
   if (!artifactResponse.ok) {
     throw await buildHttpError(artifactResponse, {
-      label: 'Search results enriched artifact download',
+      label: `${label} artifact download`,
       method: 'GET',
       hint: 'The signed file URL may be expired or inaccessible. Re-run the export command to mint a fresh URL.',
     });
@@ -2830,7 +4126,7 @@ async function handleDataExportSearchResults(opts) {
 
   const outPath = opts.stdout
     ? null
-    : (opts.out || trimString(metadata?.filename || '') || 'tracking-ranked-videos.csv');
+    : (opts.out || trimString(metadata?.filename || '') || `${template}.csv`);
   if (outPath) {
     await pipeline(artifactResponse.body, fs.createWriteStream(outPath));
     process.stderr.write(`[socialseal] Export written to ${outPath}\n`);
@@ -2839,6 +4135,261 @@ async function handleDataExportSearchResults(opts) {
   }
 }
 
+async function handleDataExportSearchResults(opts) {
+  const config = loadConfig();
+  const apiKey = requireApiKey(opts, config);
+  const apiBase = resolveApiBase(opts, config);
+  const supabaseUrl = resolveLegacyUrl(resolveSupabaseUrl(opts, config), 'SOCIALSEAL_SUPABASE_URL');
+  const { resolvedApiBase, legacyUrl, useGateway } = resolveApiTarget({ apiBase, legacyUrl: supabaseUrl });
+  const timeoutMs = resolveTimeoutMs(opts, config);
+  const { workspaceId: resolvedWorkspaceId, source: workspaceSource } = resolveWorkspaceSelection(opts, config);
+
+  const rawPayload = opts.__rawPayload ?? stripUndefinedEntries({
+    groupIds: normalizePositiveIntegerList(opts.groupIds, 'groupIds', { max: 100 }),
+    trackingItemIds: normalizePositiveIntegerList(opts.trackingItemIds, 'trackingItemIds', { max: 1000 }),
+    dateFrom: opts.dateFrom,
+    dateTo: opts.dateTo,
+    filename: opts.filename,
+  });
+
+  const payloadWorkspaceId = resolvePayloadWorkspaceId(rawPayload, null);
+  const effectiveWorkspaceId = requireWorkspaceSelection(payloadWorkspaceId || resolvedWorkspaceId, {
+    label: 'Search results enriched export',
+    hint: 'Pass --workspace-id, set SOCIALSEAL_WORKSPACE_ID, or configure a default workspace before exporting.',
+  });
+  const effectiveWorkspaceSource = payloadWorkspaceId ? 'body' : workspaceSource;
+  emitWorkspaceSelectionNotice(opts, {
+    workspaceId: effectiveWorkspaceId,
+    source: effectiveWorkspaceSource,
+    label: 'search_results_enriched export',
+  });
+
+  const normalizedPayload = buildSearchResultsEnrichedExportPayload(rawPayload, effectiveWorkspaceId);
+  const requestedFilename = trimString(normalizedPayload.filename) || undefined;
+  delete normalizedPayload.filename;
+
+  await runExportDataCsv({
+    opts,
+    label: 'Search results enriched export',
+    template: EXPORT_DATA_TEMPLATE_TRACKING_RANKED_VIDEOS_RAW,
+    normalizedPayload,
+    requestedFilename,
+    effectiveWorkspaceId,
+    apiBase: resolvedApiBase,
+    apiKey,
+    useGateway,
+    legacyUrl,
+    timeoutMs,
+  });
+}
+
+async function handleDataExportGroupEvidence(opts) {
+  const config = loadConfig();
+  const apiKey = requireApiKey(opts, config);
+  const apiBase = resolveApiBase(opts, config);
+  const supabaseUrl = resolveLegacyUrl(resolveSupabaseUrl(opts, config), 'SOCIALSEAL_SUPABASE_URL');
+  const { resolvedApiBase, legacyUrl, useGateway } = resolveApiTarget({ apiBase, legacyUrl: supabaseUrl });
+  const timeoutMs = resolveTimeoutMs(opts, config);
+  const { workspaceId: resolvedWorkspaceId, source: workspaceSource } = resolveWorkspaceSelection(opts, config);
+
+  const groupId = coercePositiveInteger(opts.groupId, 'group_id');
+  const effectiveWorkspaceId = requireWorkspaceSelection(resolvedWorkspaceId, {
+    label: 'Group evidence export',
+    hint: 'Pass --workspace-id, set SOCIALSEAL_WORKSPACE_ID, or configure a default workspace before exporting group evidence.',
+  });
+  emitWorkspaceSelectionNotice(opts, {
+    workspaceId: effectiveWorkspaceId,
+    source: workspaceSource,
+    label: 'group evidence export',
+  });
+
+  const requestedSurface = normalizeEvidenceSurface(opts.surface);
+  let surface = requestedSurface;
+  if (requestedSurface === 'auto') {
+    const groupResponse = await callApi({
+      apiBase: useGateway ? resolvedApiBase : legacyUrl,
+      apiKey,
+      path: useGateway
+        ? `/cli/tools/group-management/groups/${groupId}?workspace_id=${encodeURIComponent(effectiveWorkspaceId)}`
+        : `/functions/v1/group-management/groups/${groupId}?workspace_id=${encodeURIComponent(effectiveWorkspaceId)}`,
+      method: 'GET',
+      workspaceId: effectiveWorkspaceId,
+      timeoutMs,
+    });
+
+    if (!groupResponse.ok) {
+      throw await buildHttpError(groupResponse, {
+        label: 'Group evidence platform detection',
+        functionName: 'group-management',
+        method: 'GET',
+      });
+    }
+
+    const groupData = await groupResponse.json();
+    surface = resolveEvidenceSurfaceFromGroup(groupData);
+  }
+
+  const rawPayload = stripUndefinedEntries({
+    groupId,
+    groupIds: surface === 'social' ? [groupId] : undefined,
+    trackingItemIds: normalizePositiveIntegerList(opts.trackingItemIds, 'trackingItemIds', { max: 1000 }),
+    dateFrom: opts.dateFrom,
+    dateTo: opts.dateTo,
+    filename: opts.filename,
+  });
+  const normalizedPayload = surface === 'google_ai'
+    ? buildGoogleAiSearchSummariesExportPayload(rawPayload, effectiveWorkspaceId)
+    : buildSearchResultsEnrichedExportPayload(rawPayload, effectiveWorkspaceId);
+  const requestedFilename = trimString(normalizedPayload.filename) || undefined;
+  delete normalizedPayload.filename;
+  const template = surface === 'google_ai'
+    ? EXPORT_DATA_TEMPLATE_GOOGLE_AI_SEARCH_SUMMARIES_RAW
+    : EXPORT_DATA_TEMPLATE_TRACKING_RANKED_VIDEOS_RAW;
+
+  await runExportDataCsv({
+    opts,
+    label: 'Group evidence export',
+    template,
+    normalizedPayload,
+    requestedFilename,
+    effectiveWorkspaceId,
+    apiBase: resolvedApiBase,
+    apiKey,
+    useGateway,
+    legacyUrl,
+    timeoutMs,
+    decorateResponse: (responseJson) => ({
+      ...responseJson,
+      evidence: buildGroupEvidenceMetadata({
+        surface,
+        groupId,
+        workspaceId: effectiveWorkspaceId,
+        responseJson,
+      }),
+    }),
+  });
+}
+
+async function handleDataGroupCompleteness(opts) {
+  const config = loadConfig();
+  const apiKey = requireApiKey(opts, config);
+  const apiBase = resolveApiBase(opts, config);
+  const supabaseUrl = resolveLegacyUrl(resolveSupabaseUrl(opts, config), 'SOCIALSEAL_SUPABASE_URL');
+  const { resolvedApiBase, legacyUrl, useGateway } = resolveApiTarget({ apiBase, legacyUrl: supabaseUrl });
+  const timeoutMs = resolveTimeoutMs(opts, config);
+  const { workspaceId: resolvedWorkspaceId, source: workspaceSource } = resolveWorkspaceSelection(opts, config);
+
+  const groupId = coercePositiveInteger(opts.groupId, 'group_id');
+  const effectiveWorkspaceId = requireWorkspaceSelection(resolvedWorkspaceId, {
+    label: 'Group completeness check',
+    hint: 'Pass --workspace-id, set SOCIALSEAL_WORKSPACE_ID, or configure a default workspace before checking group completeness.',
+  });
+  emitWorkspaceSelectionNotice(opts, {
+    workspaceId: effectiveWorkspaceId,
+    source: workspaceSource,
+    label: 'group completeness check',
+  });
+
+  const manifest = parseJsonInput(opts.manifest, { label: 'manifest' });
+  const expectedItems = extractExpectedManifestItems(manifest);
+  const backendPath = useGateway
+    ? `/cli/tools/group-management/groups/${groupId}/completeness?${new URLSearchParams({
+      workspace_id: effectiveWorkspaceId,
+    }).toString()}`
+    : `/functions/v1/group-management/groups/${groupId}/completeness?${new URLSearchParams({
+      workspace_id: effectiveWorkspaceId,
+    }).toString()}`;
+
+  const backendRes = await callApi({
+    apiBase: useGateway ? resolvedApiBase : legacyUrl,
+    apiKey,
+    path: backendPath,
+    method: 'POST',
+    body: {
+      expected_items: expectedItems,
+      include_refresh_status: true,
+    },
+    workspaceId: effectiveWorkspaceId,
+    timeoutMs,
+  });
+
+  if (backendRes.ok) {
+    const contentType = backendRes.headers.get('content-type') || '';
+    if (!contentType.includes('application/json')) {
+      throw new CliError('Group completeness check returned a non-JSON response.', {
+        code: 'INVALID_RESPONSE',
+        exitCode: EXIT_CODES.SERVER,
+      });
+    }
+    const backendData = await backendRes.json();
+    emitJsonOutput(backendData, opts.pretty);
+    if (isJsonObject(backendData) && backendData.complete === false) {
+      process.exitCode = EXIT_CODES.SERVER;
+    }
+    return;
+  }
+
+  if (backendRes.status !== 404) {
+    throw await buildHttpError(backendRes, {
+      label: 'Group completeness check',
+      functionName: 'group-management',
+      method: 'POST',
+    });
+  }
+
+  const res = await callApi({
+    apiBase: useGateway ? resolvedApiBase : legacyUrl,
+    apiKey,
+    path: useGateway
+      ? `/cli/tools/group-management/groups/${groupId}/items?${new URLSearchParams({
+        workspace_id: effectiveWorkspaceId,
+        page: '1',
+        limit: String(Math.max(expectedItems.length + 100, 1000)),
+      }).toString()}`
+      : `/functions/v1/group-management/groups/${groupId}/items?${new URLSearchParams({
+        workspace_id: effectiveWorkspaceId,
+        page: '1',
+        limit: String(Math.max(expectedItems.length + 100, 1000)),
+      }).toString()}`,
+    method: 'GET',
+    workspaceId: effectiveWorkspaceId,
+    timeoutMs,
+  });
+
+  if (!res.ok) {
+    throw await buildHttpError(res, {
+      label: 'Group completeness check',
+      functionName: 'group-management',
+      method: 'GET',
+    });
+  }
+
+  const contentType = res.headers.get('content-type') || '';
+  if (!contentType.includes('application/json')) {
+    throw new CliError('Group completeness check returned a non-JSON response.', {
+      code: 'INVALID_RESPONSE',
+      exitCode: EXIT_CODES.SERVER,
+    });
+  }
+
+  const data = await res.json();
+  const actualItems = isJsonObject(data) && Array.isArray(data.items)
+    ? data.items
+    : (Array.isArray(data) ? data : []);
+  const diff = buildCompletenessDiff({
+    expectedItems,
+    actualItems,
+    groupId,
+    workspaceId: effectiveWorkspaceId,
+  });
+  diff.source = 'manifest_fallback';
+
+  emitJsonOutput(diff, opts.pretty);
+  if (!diff.complete) {
+    process.exitCode = EXIT_CODES.SERVER;
+  }
+}
+
 function handleDataExportOptions(opts) {
   const payload = {
     exports: EXPORT_OPTIONS,
@@ -3200,7 +4751,7 @@ if (typeof program.showHelpAfterError === 'function') {
 if (typeof program.showSuggestionAfterError === 'function') {
   program.showSuggestionAfterError(true);
 }
-program.addHelpText('after', `\nExamples:\n  socialseal workspace list\n  socialseal workspace use <workspace-id>\n  socialseal agent run --message \"ping\"\n  socialseal tools list\n  socialseal tools call --function <tool> --body @payload.json\n  socialseal tools call --function search-journey-run --body @payload.json --async --workspace-id <uuid>\n  socialseal video queue-analysis --video-id 734829384 --workspace-id <uuid>\n  socialseal video extract --video-id 734829384 --wait --out-dir ./video-assets\n  socialseal data export-options\n  socialseal data export-tracking --group-id 123 --time-period 30d\n  socialseal data export-search-results --group-ids 123,124 --workspace-id <uuid> --out ranked.csv\n`);
+program.addHelpText('after', `\nExamples:\n  socialseal workspace list\n  socialseal workspace use <workspace-id>\n  socialseal agent run --message "ping"\n  socialseal tools list\n  socialseal tools schema --function search-journey-run\n  socialseal tools call --function <tool> --body @payload.json\n  socialseal tools status 6809 --kind google_ai_run\n  socialseal tools status <run-uuid> --kind journey_run --workspace-id <uuid>\n  socialseal video queue-analysis --video-id 734829384 --workspace-id <uuid>\n  socialseal video extract --video-id 734829384 --wait --out-dir ./video-assets\n  socialseal data export-options\n  socialseal data export-tracking --group-id 123 --time-period 30d\n  socialseal data export-search-results --group-ids 123,124 --workspace-id <uuid> --out ranked.csv\n  socialseal data export-group-evidence --group-id 123 --workspace-id <uuid> --out evidence.csv\n`);
 
 program
   .command('agent')
@@ -3273,6 +4824,15 @@ tools
   .option('--verbose', 'Show error details')
   .action((opts) => runCommand(handleToolsList, opts));
 
+tools
+  .command('schema')
+  .description('Show static payload schema hints and examples for a tool')
+  .option('--function <name>', 'Tool name (omit to list all schema hints)')
+  .option('--json', 'Emit machine-readable output')
+  .option('--pretty', 'Pretty-print JSON')
+  .option('--verbose', 'Show error details')
+  .action((opts) => runCommand(handleToolsSchema, opts));
+
 tools
   .command('call')
   .requiredOption('--function <name>', 'Tool name (see official docs)')
@@ -3290,6 +4850,23 @@ tools
   .option('--verbose', 'Show error details')
   .action((opts) => runCommand(handleToolsCall, opts));
 
+tools
+  .command('status <id>')
+  .description('Read unified status for UUID jobs, journey run UUIDs, or numeric Google AI run ids')
+  .option('--kind <kind>', 'auto|agent_job|google_ai_run|journey_run', 'auto')
+  .option('--wait', 'Poll until status reaches a terminal state')
+  .option('--poll-interval <ms>', 'Polling interval in milliseconds when --wait is enabled')
+  .option('--include-results', 'Include Google AI summary/citation rows when reading numeric run ids')
+  .option('--results-limit <n>', 'Max Google AI summary rows to include when --include-results is set')
+  .option('--api-base <url>', 'API base URL (default https://api.socialseal.co)')
+  .option('--api-key <key>', 'CLI API key')
+  .option('--workspace-id <id>', 'Workspace id (required for journey_run status)')
+  .option('--pretty', 'Pretty-print JSON')
+  .option('--json', 'Emit machine-readable errors')
+  .option('--timeout <ms>', 'Request timeout in milliseconds')
+  .option('--verbose', 'Show error details')
+  .action((id, opts) => runCommand(handleToolsStatus, { ...opts, id }));
+
 const data = program.command('data').description('Data exports (provisional)');
 
 data
@@ -3335,6 +4912,40 @@ data
   .option('--verbose', 'Show error details')
   .action((opts) => runCommand(handleDataExportSearchResults, opts));
 
+data
+  .command('export-group-evidence')
+  .description('Export usable group evidence, routing social groups and Google AI groups to the correct CSV export')
+  .requiredOption('--group-id <id>', 'Tracking group id')
+  .option('--surface <surface>', 'auto|social|google_ai', 'auto')
+  .option('--tracking-item-ids <ids>', 'Optional comma-separated tracking item ids')
+  .option('--date-from <iso>', 'Optional ISO datetime lower bound for social ranked exports')
+  .option('--date-to <iso>', 'Optional ISO datetime upper bound for social ranked exports')
+  .option('--filename <name>', 'Optional export filename stem (without extension)')
+  .option('--out <path>', 'Output file path')
+  .option('--stdout', 'Write to stdout')
+  .option('--api-base <url>', 'API base URL (default https://api.socialseal.co)')
+  .option('--api-key <key>', 'CLI API key')
+  .option('--workspace-id <id>', 'Workspace id (for scoped keys)')
+  .option('--pretty', 'Pretty-print JSON metadata when no file is ready')
+  .option('--json', 'Emit machine-readable errors')
+  .option('--timeout <ms>', 'Request timeout in milliseconds')
+  .option('--verbose', 'Show error details')
+  .action((opts) => runCommand(handleDataExportGroupEvidence, opts));
+
+data
+  .command('group-completeness')
+  .description('Compare an expected tracking-item manifest against current group items')
+  .requiredOption('--group-id <id>', 'Tracking group id')
+  .requiredOption('--manifest <jsonOrFile>', 'Expected items manifest JSON or @file.json')
+  .option('--api-base <url>', 'API base URL (default https://api.socialseal.co)')
+  .option('--api-key <key>', 'CLI API key')
+  .option('--workspace-id <id>', 'Workspace id (for scoped keys)')
+  .option('--pretty', 'Pretty-print JSON')
+  .option('--json', 'Emit machine-readable errors')
+  .option('--timeout <ms>', 'Request timeout in milliseconds')
+  .option('--verbose', 'Show error details')
+  .action((opts) => runCommand(handleDataGroupCompleteness, opts));
+
 data
   .command('export-report')
   .description('Export report data via export-report (provisional)')