selftune 0.1.4 → 0.2.1

package/cli/selftune/canonical-export.ts

@@ -0,0 +1,183 @@
+#!/usr/bin/env bun
+
+import { randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { CANONICAL_LOG, CLAUDE_CODE_PROJECTS_DIR, EVOLUTION_EVIDENCE_LOG } from "./constants.js";
+import {
+  buildCanonicalRecordsFromReplay,
+  findTranscriptFiles,
+  parseSession,
+} from "./ingestors/claude-replay.js";
+import {
+  CANONICAL_PLATFORMS,
+  CANONICAL_RECORD_KINDS,
+  type CanonicalPlatform,
+  type CanonicalRecord,
+  type CanonicalRecordKind,
+  type EvolutionEvidenceEntry,
+} from "./types.js";
+import {
+  filterCanonicalRecords,
+  readCanonicalRecords,
+  serializeCanonicalRecords,
+} from "./utils/canonical-log.js";
+import { readJsonl } from "./utils/jsonl.js";
+
+function exitWithUsage(message?: string): never {
+  if (message) console.error(`[ERROR] ${message}`);
+  console.error(
+    `Usage: selftune export-canonical [--out FILE] [--platform NAME] [--record-kind KIND] [--pretty] [--log FILE] [--projects-dir PATH] [--push-payload]`,
+  );
+  process.exit(1);
+}
+
+function validatePlatform(value: string | undefined): CanonicalPlatform | undefined {
+  if (!value) return undefined;
+  if (!CANONICAL_PLATFORMS.includes(value as CanonicalPlatform)) {
+    exitWithUsage(`Unknown platform: ${value}`);
+  }
+  return value as CanonicalPlatform;
+}
+
+function validateRecordKind(value: string | undefined): CanonicalRecordKind | undefined {
+  if (!value) return undefined;
+  if (!CANONICAL_RECORD_KINDS.includes(value as CanonicalRecordKind)) {
+    exitWithUsage(`Unknown record kind: ${value}`);
+  }
+  return value as CanonicalRecordKind;
+}
+
+function getClientVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(import.meta.dir, "../../package.json"), "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+export function loadCanonicalRecordsForExport(
+  logPath: string = CANONICAL_LOG,
+  projectsDir: string = CLAUDE_CODE_PROJECTS_DIR,
+  platform?: CanonicalPlatform,
+): CanonicalRecord[] {
+  const canonical = readCanonicalRecords(logPath);
+  if (canonical.length > 0) return canonical;
+
+  // Existing installs may have rich Claude Code transcripts but no canonical log yet.
+  // Fall back to synthesizing exportable records directly from transcripts.
+  if (platform && platform !== "claude_code") return [];
+
+  const records: CanonicalRecord[] = [];
+  for (const transcriptPath of findTranscriptFiles(projectsDir)) {
+    const session = parseSession(transcriptPath);
+    if (!session) continue;
+    records.push(...buildCanonicalRecordsFromReplay(session));
+  }
+  return records;
+}
+
+export function buildPushPayloadV2(
+  records: CanonicalRecord[],
+  evidenceEntries: EvolutionEvidenceEntry[] = [],
+): Record<string, unknown> {
+  const sessions = records.filter((record) => record.record_kind === "session");
+  const prompts = records.filter((record) => record.record_kind === "prompt");
+  const skillInvocations = records.filter((record) => record.record_kind === "skill_invocation");
+  const executionFacts = records.filter((record) => record.record_kind === "execution_fact");
+  const normalizationRuns = records.filter((record) => record.record_kind === "normalization_run");
+  const normalizerVersion = records[0]?.normalizer_version ?? "1.0.0";
+
+  return {
+    schema_version: "2.0",
+    client_version: getClientVersion(),
+    push_id: randomUUID(),
+    normalizer_version: normalizerVersion,
+    canonical: {
+      sessions,
+      prompts,
+      skill_invocations: skillInvocations,
+      execution_facts: executionFacts,
+      normalization_runs: normalizationRuns,
+      evolution_evidence: evidenceEntries.map((entry) => ({
+        skill_name: entry.skill_name,
+        proposal_id: entry.proposal_id,
+        target: entry.target,
+        stage: entry.stage,
+        rationale: entry.rationale,
+        confidence: entry.confidence,
+        original_text: entry.original_text,
+        proposed_text: entry.proposed_text,
+        eval_set_json: entry.eval_set,
+        validation_json: entry.validation,
+      })),
+    },
+  };
+}
+
+export function cliMain(): void {
+  const { values } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      out: { type: "string" },
+      platform: { type: "string" },
+      "record-kind": { type: "string" },
+      pretty: { type: "boolean", default: false },
+      log: { type: "string", default: CANONICAL_LOG },
+      "projects-dir": { type: "string", default: CLAUDE_CODE_PROJECTS_DIR },
+      "push-payload": { type: "boolean", default: false },
+    },
+    strict: true,
+  });
+
+  const platform = validatePlatform(values.platform);
+  const recordKind = validateRecordKind(values["record-kind"]);
+  const records = filterCanonicalRecords(
+    loadCanonicalRecordsForExport(values.log, values["projects-dir"], platform),
+    {
+      platform,
+      record_kind: recordKind,
+    },
+  );
+
+  const output = values["push-payload"]
+    ? `${JSON.stringify(
+        buildPushPayloadV2(records, readJsonl<EvolutionEvidenceEntry>(EVOLUTION_EVIDENCE_LOG)),
+        null,
+        values.pretty ? 2 : undefined,
+      )}\n`
+    : serializeCanonicalRecords(records, values.pretty);
+
+  if (values.out) {
+    writeFileSync(values.out, output, "utf-8");
+    console.log(
+      JSON.stringify(
+        {
+          ok: true,
+          out: values.out,
+          count: records.length,
+          format: values["push-payload"] ? "push-payload-v2" : "jsonl",
+          pretty: values.pretty,
+          platform: platform ?? null,
+          record_kind: recordKind ?? null,
+        },
+        null,
+        values.pretty ? 2 : undefined,
+      ),
+    );
+    return;
+  }
+
+  process.stdout.write(output);
+}
+
+if (import.meta.main) {
+  try {
+    cliMain();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    exitWithUsage(message);
+  }
+}

package/cli/selftune/constants.ts

@@ -12,8 +12,21 @@ export const LOG_DIR = join(homedir(), ".claude");
 
 export const TELEMETRY_LOG = join(LOG_DIR, "session_telemetry_log.jsonl");
 export const SKILL_LOG = join(LOG_DIR, "skill_usage_log.jsonl");
+export const REPAIRED_SKILL_LOG = join(LOG_DIR, "skill_usage_repaired.jsonl");
+export const CANONICAL_LOG = join(LOG_DIR, "canonical_telemetry_log.jsonl");
+export const REPAIRED_SKILL_SESSIONS_MARKER = join(LOG_DIR, "skill_usage_repaired_sessions.json");
 export const QUERY_LOG = join(LOG_DIR, "all_queries_log.jsonl");
 export const EVOLUTION_AUDIT_LOG = join(LOG_DIR, "evolution_audit_log.jsonl");
+export const EVOLUTION_EVIDENCE_LOG = join(LOG_DIR, "evolution_evidence_log.jsonl");
+export const ORCHESTRATE_RUN_LOG = join(LOG_DIR, "orchestrate_runs.jsonl");
+export const SIGNAL_LOG = join(LOG_DIR, "improvement_signals.jsonl");
+export const ORCHESTRATE_LOCK = join(LOG_DIR, ".orchestrate.lock");
+
+/** Evolution memory directory — human-readable session context that survives resets. */
+export const MEMORY_DIR = join(SELFTUNE_CONFIG_DIR, "memory");
+export const CONTEXT_PATH = join(MEMORY_DIR, "context.md");
+export const PLAN_PATH = join(MEMORY_DIR, "plan.md");
+export const DECISIONS_PATH = join(MEMORY_DIR, "decisions.md");
 
 /** Tool names Claude Code uses. */
 export const KNOWN_TOOLS = new Set([
@@ -59,7 +72,96 @@ export const REQUIRED_FIELDS: Record<string, Set<string>> = {
   skill_usage: new Set(["timestamp", "session_id", "skill_name"]),
   all_queries: new Set(["timestamp", "session_id", "query"]),
   evolution_audit: new Set(["timestamp", "proposal_id", "action"]),
+  evolution_evidence: new Set(["timestamp", "proposal_id", "skill_name", "stage"]),
 };
 
 /** Agent CLI candidates in detection order. */
-export const AGENT_CANDIDATES = ["claude", "codex", "opencode"] as const;
+export const AGENT_CANDIDATES = ["claude", "codex", "opencode", "openclaw"] as const;
+
+/** Required Claude Code hook keys in settings.json. */
+export const CLAUDE_CODE_HOOK_KEYS = [
+  "UserPromptSubmit",
+  "PreToolUse",
+  "PostToolUse",
+  "Stop",
+] as const;
+
+/** Path for user-defined activation rule overrides. */
+export const ACTIVATION_RULES_PATH = join(SELFTUNE_CONFIG_DIR, "activation-rules.json");
+
+/** Per-session state file pattern (interpolate session_id). */
+export const SESSION_STATE_DIR = SELFTUNE_CONFIG_DIR;
+
+/** Build a session state file path from a session ID. */
+export function sessionStatePath(sessionId: string): string {
+  // Sanitize session ID to be filesystem-safe
+  const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join(SESSION_STATE_DIR, `session-state-${safe}.json`);
+}
+
+/** Build a canonical prompt state file path from a session ID. */
+export function canonicalSessionStatePath(sessionId: string): string {
+  const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join(SESSION_STATE_DIR, `canonical-session-state-${safe}.json`);
+}
+
+/** Claude Code settings file path. */
+export const CLAUDE_SETTINGS_PATH = join(homedir(), ".claude", "settings.json");
+
+/** Path to Claude Code projects directory containing session transcripts. */
+export const CLAUDE_CODE_PROJECTS_DIR = join(homedir(), ".claude", "projects");
+
+/** Marker file tracking which Claude Code sessions have been ingested. */
+export const CLAUDE_CODE_MARKER = join(homedir(), ".claude", "claude_code_ingested_sessions.json");
+
+/** Marker file tracking which Codex rollout files have been ingested. */
+export const CODEX_INGEST_MARKER = join(homedir(), ".claude", "codex_ingested_rollouts.json");
+
+/** Marker file tracking which OpenCode sessions have been ingested. */
+export const OPENCODE_INGEST_MARKER = join(homedir(), ".claude", "opencode_ingested_sessions.json");
+
+/** OpenClaw agents directory containing session data. */
+export const OPENCLAW_AGENTS_DIR = join(homedir(), ".openclaw", "agents");
+
+/** Marker file tracking which OpenClaw sessions have been ingested. */
+export const OPENCLAW_INGEST_MARKER = join(SELFTUNE_CONFIG_DIR, "openclaw-ingest-marker.json");
+
+/** Default output directory for contribution bundles. */
+export const CONTRIBUTIONS_DIR = join(SELFTUNE_CONFIG_DIR, "contributions");
+
+// ---------------------------------------------------------------------------
+// Sanitization constants (for contribute command)
+// ---------------------------------------------------------------------------
+
+/** Regex patterns for detecting secrets that must be redacted. */
+export const SECRET_PATTERNS = [
+  /sk-[a-zA-Z0-9]{20,}/g, // OpenAI / Anthropic API keys
+  /ghp_[a-zA-Z0-9]{36,}/g, // GitHub personal access tokens
+  /gho_[a-zA-Z0-9]{36,}/g, // GitHub OAuth tokens
+  /github_pat_[a-zA-Z0-9_]{22,}/g, // GitHub fine-grained PATs
+  /AKIA[A-Z0-9]{16}/g, // AWS access key IDs
+  /xoxb-[a-zA-Z0-9-]+/g, // Slack bot tokens
+  /xoxp-[a-zA-Z0-9-]+/g, // Slack user tokens
+  /xoxs-[a-zA-Z0-9-]+/g, // Slack session tokens
+  /eyJ[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}\.[a-zA-Z0-9_-]{10,}/g, // JWTs
+  /npm_[a-zA-Z0-9]{36}/g, // npm tokens
+  /pypi-[a-zA-Z0-9]{36,}/g, // PyPI tokens
+] as const;
+
+/** Regex for file paths (Unix and Windows). */
+export const FILE_PATH_PATTERN = /(?:\/[\w.-]+){2,}|[A-Z]:\\[\w\\.-]+/g;
+
+/** Regex for email addresses. */
+export const EMAIL_PATTERN = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g;
+
+/** Regex for IP addresses (v4). */
+export const IP_PATTERN = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g;
+
+/** Regex for camelCase/PascalCase identifiers longer than 8 chars (aggressive mode). */
+export const IDENTIFIER_PATTERN = /\b[a-z][a-zA-Z0-9]{8,}\b|\b[A-Z][a-zA-Z0-9]{8,}\b/g;
+
+/** Regex for import/require/from module paths (aggressive mode). */
+export const MODULE_PATTERN = /(?:import|require|from)\s+["']([^"']+)["']/g;
+
+/** Max query length for aggressive sanitization. */
+export const AGGRESSIVE_MAX_QUERY_LENGTH = 200;

package/cli/selftune/contribute/bundle.ts

@@ -0,0 +1,314 @@
+/**
+ * Bundle assembly for contribution export.
+ *
+ * Pure function: reads logs, filters, aggregates, and returns a ContributionBundle.
+ */
+
+import { randomUUID } from "node:crypto";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  EVOLUTION_AUDIT_LOG,
+  QUERY_LOG,
+  SELFTUNE_CONFIG_DIR,
+  SKILL_LOG,
+  TELEMETRY_LOG,
+} from "../constants.js";
+import { buildEvalSet, classifyInvocation } from "../eval/hooks-to-evals.js";
+import type {
+  ContributionBundle,
+  ContributionEvolutionSummary,
+  ContributionGradingSummary,
+  ContributionQuery,
+  ContributionSessionMetrics,
+  EvolutionAuditEntry,
+  GradingResult,
+  QueryLogRecord,
+  SessionTelemetryRecord,
+  SkillUsageRecord,
+} from "../types.js";
+import { readJsonl } from "../utils/jsonl.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function filterSince<T extends { timestamp: string }>(records: T[], since?: Date): T[] {
+  if (!since) return records;
+  return records.filter((r) => new Date(r.timestamp) >= since);
+}
+
+function getVersion(): string {
+  try {
+    const pkg = JSON.parse(readFileSync(join(import.meta.dir, "../../../package.json"), "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+function getAgentType(): string {
+  try {
+    const configPath = join(SELFTUNE_CONFIG_DIR, "config.json");
+    if (!existsSync(configPath)) return "unknown";
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    return config.agent_type ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+function avg(nums: number[]): number {
+  if (nums.length === 0) return 0;
+  return nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+
+// ---------------------------------------------------------------------------
+// Grading summary
+// ---------------------------------------------------------------------------
+
+function buildGradingSummary(skillName: string): ContributionGradingSummary | null {
+  const gradingDir = join(homedir(), ".selftune", "grading");
+  if (!existsSync(gradingDir)) return null;
+
+  try {
+    const files = readdirSync(gradingDir).filter((f) => f.endsWith(".json"));
+    if (files.length === 0) return null;
+
+    let totalSessions = 0;
+    let gradedSessions = 0;
+    let passRateSum = 0;
+    let expectationCount = 0;
+
+    for (const file of files) {
+      try {
+        const data = JSON.parse(readFileSync(join(gradingDir, file), "utf-8")) as GradingResult;
+        if (data.skill_name !== skillName) continue;
+        totalSessions++;
+        if (data.summary) {
+          gradedSessions++;
+          passRateSum += data.summary.pass_rate ?? 0;
+          expectationCount += data.summary.total ?? 0;
+        }
+      } catch {
+        // skip malformed grading files
+      }
+    }
+
+    if (gradedSessions === 0) return null;
+
+    return {
+      total_sessions: totalSessions,
+      graded_sessions: gradedSessions,
+      average_pass_rate: passRateSum / gradedSessions,
+      expectation_count: expectationCount,
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Evolution summary
+// ---------------------------------------------------------------------------
+
+function buildEvolutionSummary(
+  records: EvolutionAuditEntry[],
+): ContributionEvolutionSummary | null {
+  if (records.length === 0) return null;
+
+  const proposals = new Set<string>();
+  let deployed = 0;
+  let rolledBack = 0;
+  const improvements: number[] = [];
+
+  for (const r of records) {
+    proposals.add(r.proposal_id);
+    if (r.action === "deployed") {
+      deployed++;
+      if (r.eval_snapshot?.pass_rate != null) {
+        improvements.push(r.eval_snapshot.pass_rate);
+      }
+    }
+    if (r.action === "rolled_back") {
+      rolledBack++;
+    }
+  }
+
+  return {
+    total_proposals: proposals.size,
+    deployed_proposals: deployed,
+    rolled_back_proposals: rolledBack,
+    average_improvement: improvements.length > 0 ? avg(improvements) : 0,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Session metrics
+// ---------------------------------------------------------------------------
+
+function buildSessionMetrics(records: SessionTelemetryRecord[]): ContributionSessionMetrics {
+  if (records.length === 0) {
+    return {
+      total_sessions: 0,
+      avg_assistant_turns: 0,
+      avg_tool_calls: 0,
+      avg_errors: 0,
+      top_tools: [],
+    };
+  }
+
+  const toolCounts = new Map<string, number>();
+  for (const r of records) {
+    for (const [tool, count] of Object.entries(r.tool_calls ?? {})) {
+      toolCounts.set(tool, (toolCounts.get(tool) ?? 0) + count);
+    }
+  }
+
+  const topTools = [...toolCounts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([tool, count]) => ({ tool, count }));
+
+  return {
+    total_sessions: records.length,
+    avg_assistant_turns: Math.round(avg(records.map((r) => r.assistant_turns ?? 0))),
+    avg_tool_calls: Math.round(avg(records.map((r) => r.total_tool_calls ?? 0))),
+    avg_errors: Number(avg(records.map((r) => r.errors_encountered ?? 0)).toFixed(2)),
+    top_tools: topTools,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Main assembly
+// ---------------------------------------------------------------------------
+
+export function assembleBundle(options: {
+  skillName: string;
+  since?: Date;
+  sanitizationLevel: "conservative" | "aggressive";
+  queryLogPath?: string;
+  skillLogPath?: string;
+  telemetryLogPath?: string;
+  evolutionAuditLogPath?: string;
+}): ContributionBundle {
+  const {
+    skillName,
+    since,
+    sanitizationLevel,
+    queryLogPath = QUERY_LOG,
+    skillLogPath = SKILL_LOG,
+    telemetryLogPath = TELEMETRY_LOG,
+    evolutionAuditLogPath = EVOLUTION_AUDIT_LOG,
+  } = options;
+
+  // Read all logs
+  const allSkillRecords = readJsonl<SkillUsageRecord>(skillLogPath);
+  const allQueryRecords = readJsonl<QueryLogRecord>(queryLogPath);
+  const allTelemetryRecords = readJsonl<SessionTelemetryRecord>(telemetryLogPath);
+  const allEvolutionRecords = readJsonl<EvolutionAuditEntry>(evolutionAuditLogPath);
+
+  // Filter by skill and since
+  const skillRecords = filterSince(
+    allSkillRecords.filter((r) => r.skill_name === skillName),
+    since,
+  );
+  const queryRecords = filterSince(allQueryRecords, since);
+  const telemetryRecords = filterSince(
+    allTelemetryRecords.filter((r) => (r.skills_triggered ?? []).includes(skillName)),
+    since,
+  );
+  // TODO: Filter evolution records by skillName once EvolutionAuditEntry gains a skill_name field.
+  // Currently includes all skills' proposals. Schema change requires human review (escalation-policy.md).
+  const evolutionRecords = filterSince(allEvolutionRecords, since);
+
+  // Build positive queries
+  const seenQueries = new Set<string>();
+  const positiveQueries: ContributionQuery[] = [];
+  const triggeredQueryTexts = new Set<string>();
+  for (const r of skillRecords) {
+    const q = (r.query ?? "").trim();
+    if (r.triggered) triggeredQueryTexts.add(q);
+    if (!q || seenQueries.has(q)) continue;
+    seenQueries.add(q);
+    positiveQueries.push({
+      query: q,
+      invocation_type: classifyInvocation(q, skillName),
+      source: r.source ?? "skill_log",
+    });
+  }
+
+  // Build unmatched queries: queries with no matching triggered skill record
+  const unmatchedQueries = queryRecords
+    .filter((r) => !triggeredQueryTexts.has((r.query ?? "").trim()))
+    .map((r) => ({ query: (r.query ?? "").trim(), timestamp: r.timestamp }))
+    .filter((r) => r.query.length > 0);
+
+  // Build pending proposals: proposals with created/validated but no terminal action
+  const terminalActions = new Set(["deployed", "rejected", "rolled_back"]);
+  const proposalActions = new Map<string, EvolutionAuditEntry[]>();
+  for (const r of evolutionRecords) {
+    const entries = proposalActions.get(r.proposal_id) ?? [];
+    entries.push(r);
+    proposalActions.set(r.proposal_id, entries);
+  }
+  const pendingProposals: Array<{
+    proposal_id: string;
+    skill_name?: string;
+    action: string;
+    timestamp: string;
+    details: string;
+  }> = [];
+  for (const [proposalId, entries] of proposalActions) {
+    const hasTerminal = entries.some((e) => terminalActions.has(e.action));
+    if (!hasTerminal) {
+      // Use the latest entry for this proposal
+      const latest = entries[entries.length - 1];
+      pendingProposals.push({
+        proposal_id: proposalId,
+        skill_name: latest.skill_name,
+        action: latest.action,
+        timestamp: latest.timestamp,
+        details: latest.details,
+      });
+    }
+  }
+
+  // Build eval entries
+  const evalEntries = buildEvalSet(skillRecords, queryRecords, skillName, 50, true, 42, true).map(
+    (e) => ({
+      query: e.query,
+      should_trigger: e.should_trigger,
+      invocation_type: e.invocation_type,
+    }),
+  );
+
+  // Build grading summary
+  const gradingSummary = buildGradingSummary(skillName);
+
+  // Build evolution summary
+  const evolutionSummary = buildEvolutionSummary(evolutionRecords);
+
+  // Build session metrics
+  const sessionMetrics = buildSessionMetrics(telemetryRecords);
+
+  const hasNewFields = unmatchedQueries.length > 0 || pendingProposals.length > 0;
+
+  return {
+    schema_version: hasNewFields ? "1.2" : "1.1",
+    skill_name: skillName,
+    contributor_id: randomUUID(),
+    created_at: new Date().toISOString(),
+    selftune_version: getVersion(),
+    agent_type: getAgentType(),
+    sanitization_level: sanitizationLevel,
+    positive_queries: positiveQueries,
+    eval_entries: evalEntries,
+    grading_summary: gradingSummary,
+    evolution_summary: evolutionSummary,
+    session_metrics: sessionMetrics,
+    ...(unmatchedQueries.length > 0 ? { unmatched_queries: unmatchedQueries } : {}),
+    ...(pendingProposals.length > 0 ? { pending_proposals: pendingProposals } : {}),
+  };
+}